true
+ *
+ * _.eq(object, other);
+ * // => false
+ *
+ * _.eq('a', 'a');
+ * // => true
+ *
+ * _.eq('a', Object('a'));
+ * // => false
+ *
+ * _.eq(NaN, NaN);
+ * // => true
+ */
+function eq(value,other){return value===other||value!==value&&other!==other}module.exports=eq},{}],232:[function(require,module,exports){var arrayFilter=require("./_arrayFilter"),baseFilter=require("./_baseFilter"),baseIteratee=require("./_baseIteratee"),isArray=require("./isArray");
+/**
+ * Iterates over elements of `collection`, returning an array of all elements
+ * `predicate` returns truthy for. The predicate is invoked with three
+ * arguments: (value, index|key, collection).
+ *
+ * **Note:** Unlike `_.remove`, this method returns a new array.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Collection
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {Function} [predicate=_.identity] The function invoked per iteration.
+ * @returns {Array} Returns the new filtered array.
+ * @see _.reject
+ * @example
+ *
+ * var users = [
+ * { 'user': 'barney', 'age': 36, 'active': true },
+ * { 'user': 'fred', 'age': 40, 'active': false }
+ * ];
+ *
+ * _.filter(users, function(o) { return !o.active; });
+ * // => objects for ['fred']
+ *
+ * // The `_.matches` iteratee shorthand.
+ * _.filter(users, { 'age': 36, 'active': true });
+ * // => objects for ['barney']
+ *
+ * // The `_.matchesProperty` iteratee shorthand.
+ * _.filter(users, ['active', false]);
+ * // => objects for ['fred']
+ *
+ * // The `_.property` iteratee shorthand.
+ * _.filter(users, 'active');
+ * // => objects for ['barney']
+ */function filter(collection,predicate){var func=isArray(collection)?arrayFilter:baseFilter;return func(collection,baseIteratee(predicate,3))}module.exports=filter},{"./_arrayFilter":65,"./_baseFilter":84,"./_baseIteratee":105,"./isArray":243}],233:[function(require,module,exports){var createFind=require("./_createFind"),findIndex=require("./findIndex");
+/**
+ * Iterates over elements of `collection`, returning the first element
+ * `predicate` returns truthy for. The predicate is invoked with three
+ * arguments: (value, index|key, collection).
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Collection
+ * @param {Array|Object} collection The collection to inspect.
+ * @param {Function} [predicate=_.identity] The function invoked per iteration.
+ * @param {number} [fromIndex=0] The index to search from.
+ * @returns {*} Returns the matched element, else `undefined`.
+ * @example
+ *
+ * var users = [
+ * { 'user': 'barney', 'age': 36, 'active': true },
+ * { 'user': 'fred', 'age': 40, 'active': false },
+ * { 'user': 'pebbles', 'age': 1, 'active': true }
+ * ];
+ *
+ * _.find(users, function(o) { return o.age < 40; });
+ * // => object for 'barney'
+ *
+ * // The `_.matches` iteratee shorthand.
+ * _.find(users, { 'age': 1, 'active': true });
+ * // => object for 'pebbles'
+ *
+ * // The `_.matchesProperty` iteratee shorthand.
+ * _.find(users, ['active', false]);
+ * // => object for 'fred'
+ *
+ * // The `_.property` iteratee shorthand.
+ * _.find(users, 'active');
+ * // => object for 'barney'
+ */var find=createFind(findIndex);module.exports=find},{"./_createFind":150,"./findIndex":234}],234:[function(require,module,exports){var baseFindIndex=require("./_baseFindIndex"),baseIteratee=require("./_baseIteratee"),toInteger=require("./toInteger");
+/* Built-in method references for those with the same name as other `lodash` methods. */var nativeMax=Math.max;
+/**
+ * This method is like `_.find` except that it returns the index of the first
+ * element `predicate` returns truthy for instead of the element itself.
+ *
+ * @static
+ * @memberOf _
+ * @since 1.1.0
+ * @category Array
+ * @param {Array} array The array to inspect.
+ * @param {Function} [predicate=_.identity] The function invoked per iteration.
+ * @param {number} [fromIndex=0] The index to search from.
+ * @returns {number} Returns the index of the found element, else `-1`.
+ * @example
+ *
+ * var users = [
+ * { 'user': 'barney', 'active': false },
+ * { 'user': 'fred', 'active': false },
+ * { 'user': 'pebbles', 'active': true }
+ * ];
+ *
+ * _.findIndex(users, function(o) { return o.user == 'barney'; });
+ * // => 0
+ *
+ * // The `_.matches` iteratee shorthand.
+ * _.findIndex(users, { 'user': 'fred', 'active': false });
+ * // => 1
+ *
+ * // The `_.matchesProperty` iteratee shorthand.
+ * _.findIndex(users, ['active', false]);
+ * // => 0
+ *
+ * // The `_.property` iteratee shorthand.
+ * _.findIndex(users, 'active');
+ * // => 2
+ */function findIndex(array,predicate,fromIndex){var length=array==null?0:array.length;if(!length){return-1}var index=fromIndex==null?0:toInteger(fromIndex);if(index<0){index=nativeMax(length+index,0)}return baseFindIndex(array,baseIteratee(predicate,3),index)}module.exports=findIndex},{"./_baseFindIndex":85,"./_baseIteratee":105,"./toInteger":280}],235:[function(require,module,exports){var baseFlatten=require("./_baseFlatten");
+/**
+ * Flattens `array` a single level deep.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Array
+ * @param {Array} array The array to flatten.
+ * @returns {Array} Returns the new flattened array.
+ * @example
+ *
+ * _.flatten([1, [2, [3, [4]], 5]]);
+ * // => [1, 2, [3, [4]], 5]
+ */function flatten(array){var length=array==null?0:array.length;return length?baseFlatten(array,1):[]}module.exports=flatten},{"./_baseFlatten":86}],236:[function(require,module,exports){var arrayEach=require("./_arrayEach"),baseEach=require("./_baseEach"),castFunction=require("./_castFunction"),isArray=require("./isArray");
+/**
+ * Iterates over elements of `collection` and invokes `iteratee` for each element.
+ * The iteratee is invoked with three arguments: (value, index|key, collection).
+ * Iteratee functions may exit iteration early by explicitly returning `false`.
+ *
+ * **Note:** As with other "Collections" methods, objects with a "length"
+ * property are iterated like arrays. To avoid this behavior use `_.forIn`
+ * or `_.forOwn` for object iteration.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @alias each
+ * @category Collection
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {Function} [iteratee=_.identity] The function invoked per iteration.
+ * @returns {Array|Object} Returns `collection`.
+ * @see _.forEachRight
+ * @example
+ *
+ * _.forEach([1, 2], function(value) {
+ * console.log(value);
+ * });
+ * // => Logs `1` then `2`.
+ *
+ * _.forEach({ 'a': 1, 'b': 2 }, function(value, key) {
+ * console.log(key);
+ * });
+ * // => Logs 'a' then 'b' (iteration order is not guaranteed).
+ */function forEach(collection,iteratee){var func=isArray(collection)?arrayEach:baseEach;return func(collection,castFunction(iteratee))}module.exports=forEach},{"./_arrayEach":64,"./_baseEach":82,"./_castFunction":132,"./isArray":243}],237:[function(require,module,exports){var baseFor=require("./_baseFor"),castFunction=require("./_castFunction"),keysIn=require("./keysIn");
+/**
+ * Iterates over own and inherited enumerable string keyed properties of an
+ * object and invokes `iteratee` for each property. The iteratee is invoked
+ * with three arguments: (value, key, object). Iteratee functions may exit
+ * iteration early by explicitly returning `false`.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.3.0
+ * @category Object
+ * @param {Object} object The object to iterate over.
+ * @param {Function} [iteratee=_.identity] The function invoked per iteration.
+ * @returns {Object} Returns `object`.
+ * @see _.forInRight
+ * @example
+ *
+ * function Foo() {
+ * this.a = 1;
+ * this.b = 2;
+ * }
+ *
+ * Foo.prototype.c = 3;
+ *
+ * _.forIn(new Foo, function(value, key) {
+ * console.log(key);
+ * });
+ * // => Logs 'a', 'b', then 'c' (iteration order is not guaranteed).
+ */function forIn(object,iteratee){return object==null?object:baseFor(object,castFunction(iteratee),keysIn)}module.exports=forIn},{"./_baseFor":87,"./_castFunction":132,"./keysIn":260}],238:[function(require,module,exports){var baseGet=require("./_baseGet");
+/**
+ * Gets the value at `path` of `object`. If the resolved value is
+ * `undefined`, the `defaultValue` is returned in its place.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.7.0
+ * @category Object
+ * @param {Object} object The object to query.
+ * @param {Array|string} path The path of the property to get.
+ * @param {*} [defaultValue] The value returned for `undefined` resolved values.
+ * @returns {*} Returns the resolved value.
+ * @example
+ *
+ * var object = { 'a': [{ 'b': { 'c': 3 } }] };
+ *
+ * _.get(object, 'a[0].b.c');
+ * // => 3
+ *
+ * _.get(object, ['a', '0', 'b', 'c']);
+ * // => 3
+ *
+ * _.get(object, 'a.b.c', 'default');
+ * // => 'default'
+ */function get(object,path,defaultValue){var result=object==null?undefined:baseGet(object,path);return result===undefined?defaultValue:result}module.exports=get},{"./_baseGet":89}],239:[function(require,module,exports){var baseHas=require("./_baseHas"),hasPath=require("./_hasPath");
+/**
+ * Checks if `path` is a direct property of `object`.
+ *
+ * @static
+ * @since 0.1.0
+ * @memberOf _
+ * @category Object
+ * @param {Object} object The object to query.
+ * @param {Array|string} path The path to check.
+ * @returns {boolean} Returns `true` if `path` exists, else `false`.
+ * @example
+ *
+ * var object = { 'a': { 'b': 2 } };
+ * var other = _.create({ 'a': _.create({ 'b': 2 }) });
+ *
+ * _.has(object, 'a');
+ * // => true
+ *
+ * _.has(object, 'a.b');
+ * // => true
+ *
+ * _.has(object, ['a', 'b']);
+ * // => true
+ *
+ * _.has(other, 'a');
+ * // => false
+ */function has(object,path){return object!=null&&hasPath(object,path,baseHas)}module.exports=has},{"./_baseHas":93,"./_hasPath":170}],240:[function(require,module,exports){var baseHasIn=require("./_baseHasIn"),hasPath=require("./_hasPath");
+/**
+ * Checks if `path` is a direct or inherited property of `object`.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Object
+ * @param {Object} object The object to query.
+ * @param {Array|string} path The path to check.
+ * @returns {boolean} Returns `true` if `path` exists, else `false`.
+ * @example
+ *
+ * var object = _.create({ 'a': _.create({ 'b': 2 }) });
+ *
+ * _.hasIn(object, 'a');
+ * // => true
+ *
+ * _.hasIn(object, 'a.b');
+ * // => true
+ *
+ * _.hasIn(object, ['a', 'b']);
+ * // => true
+ *
+ * _.hasIn(object, 'b');
+ * // => false
+ */function hasIn(object,path){return object!=null&&hasPath(object,path,baseHasIn)}module.exports=hasIn},{"./_baseHasIn":94,"./_hasPath":170}],241:[function(require,module,exports){
+/**
+ * This method returns the first argument it receives.
+ *
+ * @static
+ * @since 0.1.0
+ * @memberOf _
+ * @category Util
+ * @param {*} value Any value.
+ * @returns {*} Returns `value`.
+ * @example
+ *
+ * var object = { 'a': 1 };
+ *
+ * console.log(_.identity(object) === object);
+ * // => true
+ */
+function identity(value){return value}module.exports=identity},{}],242:[function(require,module,exports){var baseIsArguments=require("./_baseIsArguments"),isObjectLike=require("./isObjectLike");
+/** Used for built-in method references. */var objectProto=Object.prototype;
+/** Used to check objects for own properties. */var hasOwnProperty=objectProto.hasOwnProperty;
+/** Built-in value references. */var propertyIsEnumerable=objectProto.propertyIsEnumerable;
+/**
+ * Checks if `value` is likely an `arguments` object.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an `arguments` object,
+ * else `false`.
+ * @example
+ *
+ * _.isArguments(function() { return arguments; }());
+ * // => true
+ *
+ * _.isArguments([1, 2, 3]);
+ * // => false
+ */var isArguments=baseIsArguments(function(){return arguments}())?baseIsArguments:function(value){return isObjectLike(value)&&hasOwnProperty.call(value,"callee")&&!propertyIsEnumerable.call(value,"callee")};module.exports=isArguments},{"./_baseIsArguments":96,"./isObjectLike":252}],243:[function(require,module,exports){
+/**
+ * Checks if `value` is classified as an `Array` object.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an array, else `false`.
+ * @example
+ *
+ * _.isArray([1, 2, 3]);
+ * // => true
+ *
+ * _.isArray(document.body.children);
+ * // => false
+ *
+ * _.isArray('abc');
+ * // => false
+ *
+ * _.isArray(_.noop);
+ * // => false
+ */
+var isArray=Array.isArray;module.exports=isArray},{}],244:[function(require,module,exports){var isFunction=require("./isFunction"),isLength=require("./isLength");
+/**
+ * Checks if `value` is array-like. A value is considered array-like if it's
+ * not a function and has a `value.length` that's an integer greater than or
+ * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is array-like, else `false`.
+ * @example
+ *
+ * _.isArrayLike([1, 2, 3]);
+ * // => true
+ *
+ * _.isArrayLike(document.body.children);
+ * // => true
+ *
+ * _.isArrayLike('abc');
+ * // => true
+ *
+ * _.isArrayLike(_.noop);
+ * // => false
+ */function isArrayLike(value){return value!=null&&isLength(value.length)&&!isFunction(value)}module.exports=isArrayLike},{"./isFunction":248,"./isLength":249}],245:[function(require,module,exports){var isArrayLike=require("./isArrayLike"),isObjectLike=require("./isObjectLike");
+/**
+ * This method is like `_.isArrayLike` except that it also checks if `value`
+ * is an object.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an array-like object,
+ * else `false`.
+ * @example
+ *
+ * _.isArrayLikeObject([1, 2, 3]);
+ * // => true
+ *
+ * _.isArrayLikeObject(document.body.children);
+ * // => true
+ *
+ * _.isArrayLikeObject('abc');
+ * // => false
+ *
+ * _.isArrayLikeObject(_.noop);
+ * // => false
+ */function isArrayLikeObject(value){return isObjectLike(value)&&isArrayLike(value)}module.exports=isArrayLikeObject},{"./isArrayLike":244,"./isObjectLike":252}],246:[function(require,module,exports){var root=require("./_root"),stubFalse=require("./stubFalse");
+/** Detect free variable `exports`. */var freeExports=typeof exports=="object"&&exports&&!exports.nodeType&&exports;
+/** Detect free variable `module`. */var freeModule=freeExports&&typeof module=="object"&&module&&!module.nodeType&&module;
+/** Detect the popular CommonJS extension `module.exports`. */var moduleExports=freeModule&&freeModule.exports===freeExports;
+/** Built-in value references. */var Buffer=moduleExports?root.Buffer:undefined;
+/* Built-in method references for those with the same name as other `lodash` methods. */var nativeIsBuffer=Buffer?Buffer.isBuffer:undefined;
+/**
+ * Checks if `value` is a buffer.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.3.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a buffer, else `false`.
+ * @example
+ *
+ * _.isBuffer(new Buffer(2));
+ * // => true
+ *
+ * _.isBuffer(new Uint8Array(2));
+ * // => false
+ */var isBuffer=nativeIsBuffer||stubFalse;module.exports=isBuffer},{"./_root":208,"./stubFalse":278}],247:[function(require,module,exports){var baseKeys=require("./_baseKeys"),getTag=require("./_getTag"),isArguments=require("./isArguments"),isArray=require("./isArray"),isArrayLike=require("./isArrayLike"),isBuffer=require("./isBuffer"),isPrototype=require("./_isPrototype"),isTypedArray=require("./isTypedArray");
+/** `Object#toString` result references. */var mapTag="[object Map]",setTag="[object Set]";
+/** Used for built-in method references. */var objectProto=Object.prototype;
+/** Used to check objects for own properties. */var hasOwnProperty=objectProto.hasOwnProperty;
+/**
+ * Checks if `value` is an empty object, collection, map, or set.
+ *
+ * Objects are considered empty if they have no own enumerable string keyed
+ * properties.
+ *
+ * Array-like values such as `arguments` objects, arrays, buffers, strings, or
+ * jQuery-like collections are considered empty if they have a `length` of `0`.
+ * Similarly, maps and sets are considered empty if they have a `size` of `0`.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is empty, else `false`.
+ * @example
+ *
+ * _.isEmpty(null);
+ * // => true
+ *
+ * _.isEmpty(true);
+ * // => true
+ *
+ * _.isEmpty(1);
+ * // => true
+ *
+ * _.isEmpty([1, 2, 3]);
+ * // => false
+ *
+ * _.isEmpty({ 'a': 1 });
+ * // => false
+ */function isEmpty(value){if(value==null){return true}if(isArrayLike(value)&&(isArray(value)||typeof value=="string"||typeof value.splice=="function"||isBuffer(value)||isTypedArray(value)||isArguments(value))){return!value.length}var tag=getTag(value);if(tag==mapTag||tag==setTag){return!value.size}if(isPrototype(value)){return!baseKeys(value).length}for(var key in value){if(hasOwnProperty.call(value,key)){return false}}return true}module.exports=isEmpty},{"./_baseKeys":106,"./_getTag":168,"./_isPrototype":186,"./isArguments":242,"./isArray":243,"./isArrayLike":244,"./isBuffer":246,"./isTypedArray":257}],248:[function(require,module,exports){var baseGetTag=require("./_baseGetTag"),isObject=require("./isObject");
+/** `Object#toString` result references. */var asyncTag="[object AsyncFunction]",funcTag="[object Function]",genTag="[object GeneratorFunction]",proxyTag="[object Proxy]";
+/**
+ * Checks if `value` is classified as a `Function` object.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a function, else `false`.
+ * @example
+ *
+ * _.isFunction(_);
+ * // => true
+ *
+ * _.isFunction(/abc/);
+ * // => false
+ */function isFunction(value){if(!isObject(value)){return false}
+// The use of `Object#toString` avoids issues with the `typeof` operator
+// in Safari 9 which returns 'object' for typed arrays and other constructors.
+var tag=baseGetTag(value);return tag==funcTag||tag==genTag||tag==asyncTag||tag==proxyTag}module.exports=isFunction},{"./_baseGetTag":91,"./isObject":251}],249:[function(require,module,exports){
+/** Used as references for various `Number` constants. */
+var MAX_SAFE_INTEGER=9007199254740991;
+/**
+ * Checks if `value` is a valid array-like length.
+ *
+ * **Note:** This method is loosely based on
+ * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.
+ * @example
+ *
+ * _.isLength(3);
+ * // => true
+ *
+ * _.isLength(Number.MIN_VALUE);
+ * // => false
+ *
+ * _.isLength(Infinity);
+ * // => false
+ *
+ * _.isLength('3');
+ * // => false
+ */function isLength(value){return typeof value=="number"&&value>-1&&value%1==0&&value<=MAX_SAFE_INTEGER}module.exports=isLength},{}],250:[function(require,module,exports){var baseIsMap=require("./_baseIsMap"),baseUnary=require("./_baseUnary"),nodeUtil=require("./_nodeUtil");
+/* Node.js helper references. */var nodeIsMap=nodeUtil&&nodeUtil.isMap;
+/**
+ * Checks if `value` is classified as a `Map` object.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.3.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a map, else `false`.
+ * @example
+ *
+ * _.isMap(new Map);
+ * // => true
+ *
+ * _.isMap(new WeakMap);
+ * // => false
+ */var isMap=nodeIsMap?baseUnary(nodeIsMap):baseIsMap;module.exports=isMap},{"./_baseIsMap":99,"./_baseUnary":127,"./_nodeUtil":204}],251:[function(require,module,exports){
+/**
+ * Checks if `value` is the
+ * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
+ * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an object, else `false`.
+ * @example
+ *
+ * _.isObject({});
+ * // => true
+ *
+ * _.isObject([1, 2, 3]);
+ * // => true
+ *
+ * _.isObject(_.noop);
+ * // => true
+ *
+ * _.isObject(null);
+ * // => false
+ */
+function isObject(value){var type=typeof value;return value!=null&&(type=="object"||type=="function")}module.exports=isObject},{}],252:[function(require,module,exports){
+/**
+ * Checks if `value` is object-like. A value is object-like if it's not `null`
+ * and has a `typeof` result of "object".
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
+ * @example
+ *
+ * _.isObjectLike({});
+ * // => true
+ *
+ * _.isObjectLike([1, 2, 3]);
+ * // => true
+ *
+ * _.isObjectLike(_.noop);
+ * // => false
+ *
+ * _.isObjectLike(null);
+ * // => false
+ */
+function isObjectLike(value){return value!=null&&typeof value=="object"}module.exports=isObjectLike},{}],253:[function(require,module,exports){var baseGetTag=require("./_baseGetTag"),getPrototype=require("./_getPrototype"),isObjectLike=require("./isObjectLike");
+/** `Object#toString` result references. */var objectTag="[object Object]";
+/** Used for built-in method references. */var funcProto=Function.prototype,objectProto=Object.prototype;
+/** Used to resolve the decompiled source of functions. */var funcToString=funcProto.toString;
+/** Used to check objects for own properties. */var hasOwnProperty=objectProto.hasOwnProperty;
+/** Used to infer the `Object` constructor. */var objectCtorString=funcToString.call(Object);
+/**
+ * Checks if `value` is a plain object, that is, an object created by the
+ * `Object` constructor or one with a `[[Prototype]]` of `null`.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.8.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.
+ * @example
+ *
+ * function Foo() {
+ * this.a = 1;
+ * }
+ *
+ * _.isPlainObject(new Foo);
+ * // => false
+ *
+ * _.isPlainObject([1, 2, 3]);
+ * // => false
+ *
+ * _.isPlainObject({ 'x': 0, 'y': 0 });
+ * // => true
+ *
+ * _.isPlainObject(Object.create(null));
+ * // => true
+ */function isPlainObject(value){if(!isObjectLike(value)||baseGetTag(value)!=objectTag){return false}var proto=getPrototype(value);if(proto===null){return true}var Ctor=hasOwnProperty.call(proto,"constructor")&&proto.constructor;return typeof Ctor=="function"&&Ctor instanceof Ctor&&funcToString.call(Ctor)==objectCtorString}module.exports=isPlainObject},{"./_baseGetTag":91,"./_getPrototype":164,"./isObjectLike":252}],254:[function(require,module,exports){var baseIsSet=require("./_baseIsSet"),baseUnary=require("./_baseUnary"),nodeUtil=require("./_nodeUtil");
+/* Node.js helper references. */var nodeIsSet=nodeUtil&&nodeUtil.isSet;
+/**
+ * Checks if `value` is classified as a `Set` object.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.3.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a set, else `false`.
+ * @example
+ *
+ * _.isSet(new Set);
+ * // => true
+ *
+ * _.isSet(new WeakSet);
+ * // => false
+ */var isSet=nodeIsSet?baseUnary(nodeIsSet):baseIsSet;module.exports=isSet},{"./_baseIsSet":103,"./_baseUnary":127,"./_nodeUtil":204}],255:[function(require,module,exports){var baseGetTag=require("./_baseGetTag"),isArray=require("./isArray"),isObjectLike=require("./isObjectLike");
+/** `Object#toString` result references. */var stringTag="[object String]";
+/**
+ * Checks if `value` is classified as a `String` primitive or object.
+ *
+ * @static
+ * @since 0.1.0
+ * @memberOf _
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a string, else `false`.
+ * @example
+ *
+ * _.isString('abc');
+ * // => true
+ *
+ * _.isString(1);
+ * // => false
+ */function isString(value){return typeof value=="string"||!isArray(value)&&isObjectLike(value)&&baseGetTag(value)==stringTag}module.exports=isString},{"./_baseGetTag":91,"./isArray":243,"./isObjectLike":252}],256:[function(require,module,exports){var baseGetTag=require("./_baseGetTag"),isObjectLike=require("./isObjectLike");
+/** `Object#toString` result references. */var symbolTag="[object Symbol]";
+/**
+ * Checks if `value` is classified as a `Symbol` primitive or object.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.
+ * @example
+ *
+ * _.isSymbol(Symbol.iterator);
+ * // => true
+ *
+ * _.isSymbol('abc');
+ * // => false
+ */function isSymbol(value){return typeof value=="symbol"||isObjectLike(value)&&baseGetTag(value)==symbolTag}module.exports=isSymbol},{"./_baseGetTag":91,"./isObjectLike":252}],257:[function(require,module,exports){var baseIsTypedArray=require("./_baseIsTypedArray"),baseUnary=require("./_baseUnary"),nodeUtil=require("./_nodeUtil");
+/* Node.js helper references. */var nodeIsTypedArray=nodeUtil&&nodeUtil.isTypedArray;
+/**
+ * Checks if `value` is classified as a typed array.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
+ * @example
+ *
+ * _.isTypedArray(new Uint8Array);
+ * // => true
+ *
+ * _.isTypedArray([]);
+ * // => false
+ */var isTypedArray=nodeIsTypedArray?baseUnary(nodeIsTypedArray):baseIsTypedArray;module.exports=isTypedArray},{"./_baseIsTypedArray":104,"./_baseUnary":127,"./_nodeUtil":204}],258:[function(require,module,exports){
+/**
+ * Checks if `value` is `undefined`.
+ *
+ * @static
+ * @since 0.1.0
+ * @memberOf _
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is `undefined`, else `false`.
+ * @example
+ *
+ * _.isUndefined(void 0);
+ * // => true
+ *
+ * _.isUndefined(null);
+ * // => false
+ */
+function isUndefined(value){return value===undefined}module.exports=isUndefined},{}],259:[function(require,module,exports){var arrayLikeKeys=require("./_arrayLikeKeys"),baseKeys=require("./_baseKeys"),isArrayLike=require("./isArrayLike");
+/**
+ * Creates an array of the own enumerable property names of `object`.
+ *
+ * **Note:** Non-object values are coerced to objects. See the
+ * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
+ * for more details.
+ *
+ * @static
+ * @since 0.1.0
+ * @memberOf _
+ * @category Object
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of property names.
+ * @example
+ *
+ * function Foo() {
+ * this.a = 1;
+ * this.b = 2;
+ * }
+ *
+ * Foo.prototype.c = 3;
+ *
+ * _.keys(new Foo);
+ * // => ['a', 'b'] (iteration order is not guaranteed)
+ *
+ * _.keys('hi');
+ * // => ['0', '1']
+ */function keys(object){return isArrayLike(object)?arrayLikeKeys(object):baseKeys(object)}module.exports=keys},{"./_arrayLikeKeys":68,"./_baseKeys":106,"./isArrayLike":244}],260:[function(require,module,exports){var arrayLikeKeys=require("./_arrayLikeKeys"),baseKeysIn=require("./_baseKeysIn"),isArrayLike=require("./isArrayLike");
+/**
+ * Creates an array of the own and inherited enumerable property names of `object`.
+ *
+ * **Note:** Non-object values are coerced to objects.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category Object
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of property names.
+ * @example
+ *
+ * function Foo() {
+ * this.a = 1;
+ * this.b = 2;
+ * }
+ *
+ * Foo.prototype.c = 3;
+ *
+ * _.keysIn(new Foo);
+ * // => ['a', 'b', 'c'] (iteration order is not guaranteed)
+ */function keysIn(object){return isArrayLike(object)?arrayLikeKeys(object,true):baseKeysIn(object)}module.exports=keysIn},{"./_arrayLikeKeys":68,"./_baseKeysIn":107,"./isArrayLike":244}],261:[function(require,module,exports){
+/**
+ * Gets the last element of `array`.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Array
+ * @param {Array} array The array to query.
+ * @returns {*} Returns the last element of `array`.
+ * @example
+ *
+ * _.last([1, 2, 3]);
+ * // => 3
+ */
+function last(array){var length=array==null?0:array.length;return length?array[length-1]:undefined}module.exports=last},{}],262:[function(require,module,exports){var arrayMap=require("./_arrayMap"),baseIteratee=require("./_baseIteratee"),baseMap=require("./_baseMap"),isArray=require("./isArray");
+/**
+ * Creates an array of values by running each element in `collection` thru
+ * `iteratee`. The iteratee is invoked with three arguments:
+ * (value, index|key, collection).
+ *
+ * Many lodash methods are guarded to work as iteratees for methods like
+ * `_.every`, `_.filter`, `_.map`, `_.mapValues`, `_.reject`, and `_.some`.
+ *
+ * The guarded methods are:
+ * `ary`, `chunk`, `curry`, `curryRight`, `drop`, `dropRight`, `every`,
+ * `fill`, `invert`, `parseInt`, `random`, `range`, `rangeRight`, `repeat`,
+ * `sampleSize`, `slice`, `some`, `sortBy`, `split`, `take`, `takeRight`,
+ * `template`, `trim`, `trimEnd`, `trimStart`, and `words`
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Collection
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {Function} [iteratee=_.identity] The function invoked per iteration.
+ * @returns {Array} Returns the new mapped array.
+ * @example
+ *
+ * function square(n) {
+ * return n * n;
+ * }
+ *
+ * _.map([4, 8], square);
+ * // => [16, 64]
+ *
+ * _.map({ 'a': 4, 'b': 8 }, square);
+ * // => [16, 64] (iteration order is not guaranteed)
+ *
+ * var users = [
+ * { 'user': 'barney' },
+ * { 'user': 'fred' }
+ * ];
+ *
+ * // The `_.property` iteratee shorthand.
+ * _.map(users, 'user');
+ * // => ['barney', 'fred']
+ */function map(collection,iteratee){var func=isArray(collection)?arrayMap:baseMap;return func(collection,baseIteratee(iteratee,3))}module.exports=map},{"./_arrayMap":69,"./_baseIteratee":105,"./_baseMap":109,"./isArray":243}],263:[function(require,module,exports){var baseAssignValue=require("./_baseAssignValue"),baseForOwn=require("./_baseForOwn"),baseIteratee=require("./_baseIteratee");
+/**
+ * Creates an object with the same keys as `object` and values generated
+ * by running each own enumerable string keyed property of `object` thru
+ * `iteratee`. The iteratee is invoked with three arguments:
+ * (value, key, object).
+ *
+ * @static
+ * @memberOf _
+ * @since 2.4.0
+ * @category Object
+ * @param {Object} object The object to iterate over.
+ * @param {Function} [iteratee=_.identity] The function invoked per iteration.
+ * @returns {Object} Returns the new mapped object.
+ * @see _.mapKeys
+ * @example
+ *
+ * var users = {
+ * 'fred': { 'user': 'fred', 'age': 40 },
+ * 'pebbles': { 'user': 'pebbles', 'age': 1 }
+ * };
+ *
+ * _.mapValues(users, function(o) { return o.age; });
+ * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed)
+ *
+ * // The `_.property` iteratee shorthand.
+ * _.mapValues(users, 'age');
+ * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed)
+ */function mapValues(object,iteratee){var result={};iteratee=baseIteratee(iteratee,3);baseForOwn(object,function(value,key,object){baseAssignValue(result,key,iteratee(value,key,object))});return result}module.exports=mapValues},{"./_baseAssignValue":79,"./_baseForOwn":88,"./_baseIteratee":105}],264:[function(require,module,exports){var baseExtremum=require("./_baseExtremum"),baseGt=require("./_baseGt"),identity=require("./identity");
+/**
+ * Computes the maximum value of `array`. If `array` is empty or falsey,
+ * `undefined` is returned.
+ *
+ * @static
+ * @since 0.1.0
+ * @memberOf _
+ * @category Math
+ * @param {Array} array The array to iterate over.
+ * @returns {*} Returns the maximum value.
+ * @example
+ *
+ * _.max([4, 2, 8, 6]);
+ * // => 8
+ *
+ * _.max([]);
+ * // => undefined
+ */function max(array){return array&&array.length?baseExtremum(array,identity,baseGt):undefined}module.exports=max},{"./_baseExtremum":83,"./_baseGt":92,"./identity":241}],265:[function(require,module,exports){var MapCache=require("./_MapCache");
+/** Error message constants. */var FUNC_ERROR_TEXT="Expected a function";
+/**
+ * Creates a function that memoizes the result of `func`. If `resolver` is
+ * provided, it determines the cache key for storing the result based on the
+ * arguments provided to the memoized function. By default, the first argument
+ * provided to the memoized function is used as the map cache key. The `func`
+ * is invoked with the `this` binding of the memoized function.
+ *
+ * **Note:** The cache is exposed as the `cache` property on the memoized
+ * function. Its creation may be customized by replacing the `_.memoize.Cache`
+ * constructor with one whose instances implement the
+ * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object)
+ * method interface of `clear`, `delete`, `get`, `has`, and `set`.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Function
+ * @param {Function} func The function to have its output memoized.
+ * @param {Function} [resolver] The function to resolve the cache key.
+ * @returns {Function} Returns the new memoized function.
+ * @example
+ *
+ * var object = { 'a': 1, 'b': 2 };
+ * var other = { 'c': 3, 'd': 4 };
+ *
+ * var values = _.memoize(_.values);
+ * values(object);
+ * // => [1, 2]
+ *
+ * values(other);
+ * // => [3, 4]
+ *
+ * object.a = 2;
+ * values(object);
+ * // => [1, 2]
+ *
+ * // Modify the result cache.
+ * values.cache.set(object, ['a', 'b']);
+ * values(object);
+ * // => ['a', 'b']
+ *
+ * // Replace `_.memoize.Cache`.
+ * _.memoize.Cache = WeakMap;
+ */function memoize(func,resolver){if(typeof func!="function"||resolver!=null&&typeof resolver!="function"){throw new TypeError(FUNC_ERROR_TEXT)}var memoized=function(){var args=arguments,key=resolver?resolver.apply(this,args):args[0],cache=memoized.cache;if(cache.has(key)){return cache.get(key)}var result=func.apply(this,args);memoized.cache=cache.set(key,result)||cache;return result};memoized.cache=new(memoize.Cache||MapCache);return memoized}
+// Expose `MapCache`.
+memoize.Cache=MapCache;module.exports=memoize},{"./_MapCache":55}],266:[function(require,module,exports){var baseMerge=require("./_baseMerge"),createAssigner=require("./_createAssigner");
+/**
+ * This method is like `_.assign` except that it recursively merges own and
+ * inherited enumerable string keyed properties of source objects into the
+ * destination object. Source properties that resolve to `undefined` are
+ * skipped if a destination value exists. Array and plain object properties
+ * are merged recursively. Other objects and value types are overridden by
+ * assignment. Source objects are applied from left to right. Subsequent
+ * sources overwrite property assignments of previous sources.
+ *
+ * **Note:** This method mutates `object`.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.5.0
+ * @category Object
+ * @param {Object} object The destination object.
+ * @param {...Object} [sources] The source objects.
+ * @returns {Object} Returns `object`.
+ * @example
+ *
+ * var object = {
+ * 'a': [{ 'b': 2 }, { 'd': 4 }]
+ * };
+ *
+ * var other = {
+ * 'a': [{ 'c': 3 }, { 'e': 5 }]
+ * };
+ *
+ * _.merge(object, other);
+ * // => { 'a': [{ 'b': 2, 'c': 3 }, { 'd': 4, 'e': 5 }] }
+ */var merge=createAssigner(function(object,source,srcIndex){baseMerge(object,source,srcIndex)});module.exports=merge},{"./_baseMerge":112,"./_createAssigner":147}],267:[function(require,module,exports){var baseExtremum=require("./_baseExtremum"),baseLt=require("./_baseLt"),identity=require("./identity");
+/**
+ * Computes the minimum value of `array`. If `array` is empty or falsey,
+ * `undefined` is returned.
+ *
+ * @static
+ * @since 0.1.0
+ * @memberOf _
+ * @category Math
+ * @param {Array} array The array to iterate over.
+ * @returns {*} Returns the minimum value.
+ * @example
+ *
+ * _.min([4, 2, 8, 6]);
+ * // => 2
+ *
+ * _.min([]);
+ * // => undefined
+ */function min(array){return array&&array.length?baseExtremum(array,identity,baseLt):undefined}module.exports=min},{"./_baseExtremum":83,"./_baseLt":108,"./identity":241}],268:[function(require,module,exports){var baseExtremum=require("./_baseExtremum"),baseIteratee=require("./_baseIteratee"),baseLt=require("./_baseLt");
+/**
+ * This method is like `_.min` except that it accepts `iteratee` which is
+ * invoked for each element in `array` to generate the criterion by which
+ * the value is ranked. The iteratee is invoked with one argument: (value).
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Math
+ * @param {Array} array The array to iterate over.
+ * @param {Function} [iteratee=_.identity] The iteratee invoked per element.
+ * @returns {*} Returns the minimum value.
+ * @example
+ *
+ * var objects = [{ 'n': 1 }, { 'n': 2 }];
+ *
+ * _.minBy(objects, function(o) { return o.n; });
+ * // => { 'n': 1 }
+ *
+ * // The `_.property` iteratee shorthand.
+ * _.minBy(objects, 'n');
+ * // => { 'n': 1 }
+ */function minBy(array,iteratee){return array&&array.length?baseExtremum(array,baseIteratee(iteratee,2),baseLt):undefined}module.exports=minBy},{"./_baseExtremum":83,"./_baseIteratee":105,"./_baseLt":108}],269:[function(require,module,exports){
+/**
+ * This method returns `undefined`.
+ *
+ * @static
+ * @memberOf _
+ * @since 2.3.0
+ * @category Util
+ * @example
+ *
+ * _.times(2, _.noop);
+ * // => [undefined, undefined]
+ */
+function noop(){
+// No operation performed.
+}module.exports=noop},{}],270:[function(require,module,exports){var root=require("./_root");
+/**
+ * Gets the timestamp of the number of milliseconds that have elapsed since
+ * the Unix epoch (1 January 1970 00:00:00 UTC).
+ *
+ * @static
+ * @memberOf _
+ * @since 2.4.0
+ * @category Date
+ * @returns {number} Returns the timestamp.
+ * @example
+ *
+ * _.defer(function(stamp) {
+ * console.log(_.now() - stamp);
+ * }, _.now());
+ * // => Logs the number of milliseconds it took for the deferred invocation.
+ */var now=function(){return root.Date.now()};module.exports=now},{"./_root":208}],271:[function(require,module,exports){var basePick=require("./_basePick"),flatRest=require("./_flatRest");
+/**
+ * Creates an object composed of the picked `object` properties.
+ *
+ * @static
+ * @since 0.1.0
+ * @memberOf _
+ * @category Object
+ * @param {Object} object The source object.
+ * @param {...(string|string[])} [paths] The property paths to pick.
+ * @returns {Object} Returns the new object.
+ * @example
+ *
+ * var object = { 'a': 1, 'b': '2', 'c': 3 };
+ *
+ * _.pick(object, ['a', 'c']);
+ * // => { 'a': 1, 'c': 3 }
+ */var pick=flatRest(function(object,paths){return object==null?{}:basePick(object,paths)});module.exports=pick},{"./_basePick":115,"./_flatRest":157}],272:[function(require,module,exports){var baseProperty=require("./_baseProperty"),basePropertyDeep=require("./_basePropertyDeep"),isKey=require("./_isKey"),toKey=require("./_toKey");
+/**
+ * Creates a function that returns the value at `path` of a given object.
+ *
+ * @static
+ * @memberOf _
+ * @since 2.4.0
+ * @category Util
+ * @param {Array|string} path The path of the property to get.
+ * @returns {Function} Returns the new accessor function.
+ * @example
+ *
+ * var objects = [
+ * { 'a': { 'b': 2 } },
+ * { 'a': { 'b': 1 } }
+ * ];
+ *
+ * _.map(objects, _.property('a.b'));
+ * // => [2, 1]
+ *
+ * _.map(_.sortBy(objects, _.property(['a', 'b'])), 'a.b');
+ * // => [1, 2]
+ */function property(path){return isKey(path)?baseProperty(toKey(path)):basePropertyDeep(path)}module.exports=property},{"./_baseProperty":117,"./_basePropertyDeep":118,"./_isKey":183,"./_toKey":223}],273:[function(require,module,exports){var createRange=require("./_createRange");
+/**
+ * Creates an array of numbers (positive and/or negative) progressing from
+ * `start` up to, but not including, `end`. A step of `-1` is used if a negative
+ * `start` is specified without an `end` or `step`. If `end` is not specified,
+ * it's set to `start` with `start` then set to `0`.
+ *
+ * **Note:** JavaScript follows the IEEE-754 standard for resolving
+ * floating-point values which can produce unexpected results.
+ *
+ * @static
+ * @since 0.1.0
+ * @memberOf _
+ * @category Util
+ * @param {number} [start=0] The start of the range.
+ * @param {number} end The end of the range.
+ * @param {number} [step=1] The value to increment or decrement by.
+ * @returns {Array} Returns the range of numbers.
+ * @see _.inRange, _.rangeRight
+ * @example
+ *
+ * _.range(4);
+ * // => [0, 1, 2, 3]
+ *
+ * _.range(-4);
+ * // => [0, -1, -2, -3]
+ *
+ * _.range(1, 5);
+ * // => [1, 2, 3, 4]
+ *
+ * _.range(0, 20, 5);
+ * // => [0, 5, 10, 15]
+ *
+ * _.range(0, -4, -1);
+ * // => [0, -1, -2, -3]
+ *
+ * _.range(1, 4, 0);
+ * // => [1, 1, 1]
+ *
+ * _.range(0);
+ * // => []
+ */var range=createRange();module.exports=range},{"./_createRange":151}],274:[function(require,module,exports){var arrayReduce=require("./_arrayReduce"),baseEach=require("./_baseEach"),baseIteratee=require("./_baseIteratee"),baseReduce=require("./_baseReduce"),isArray=require("./isArray");
+/**
+ * Reduces `collection` to a value which is the accumulated result of running
+ * each element in `collection` thru `iteratee`, where each successive
+ * invocation is supplied the return value of the previous. If `accumulator`
+ * is not given, the first element of `collection` is used as the initial
+ * value. The iteratee is invoked with four arguments:
+ * (accumulator, value, index|key, collection).
+ *
+ * Many lodash methods are guarded to work as iteratees for methods like
+ * `_.reduce`, `_.reduceRight`, and `_.transform`.
+ *
+ * The guarded methods are:
+ * `assign`, `defaults`, `defaultsDeep`, `includes`, `merge`, `orderBy`,
+ * and `sortBy`
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Collection
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {Function} [iteratee=_.identity] The function invoked per iteration.
+ * @param {*} [accumulator] The initial value.
+ * @returns {*} Returns the accumulated value.
+ * @see _.reduceRight
+ * @example
+ *
+ * _.reduce([1, 2], function(sum, n) {
+ * return sum + n;
+ * }, 0);
+ * // => 3
+ *
+ * _.reduce({ 'a': 1, 'b': 2, 'c': 1 }, function(result, value, key) {
+ * (result[value] || (result[value] = [])).push(key);
+ * return result;
+ * }, {});
+ * // => { '1': ['a', 'c'], '2': ['b'] } (iteration order is not guaranteed)
+ */function reduce(collection,iteratee,accumulator){var func=isArray(collection)?arrayReduce:baseReduce,initAccum=arguments.length<3;return func(collection,baseIteratee(iteratee,4),accumulator,initAccum,baseEach)}module.exports=reduce},{"./_arrayReduce":71,"./_baseEach":82,"./_baseIteratee":105,"./_baseReduce":120,"./isArray":243}],275:[function(require,module,exports){var baseKeys=require("./_baseKeys"),getTag=require("./_getTag"),isArrayLike=require("./isArrayLike"),isString=require("./isString"),stringSize=require("./_stringSize");
+/** `Object#toString` result references. */var mapTag="[object Map]",setTag="[object Set]";
+/**
+ * Gets the size of `collection` by returning its length for array-like
+ * values or the number of own enumerable string keyed properties for objects.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Collection
+ * @param {Array|Object|string} collection The collection to inspect.
+ * @returns {number} Returns the collection size.
+ * @example
+ *
+ * _.size([1, 2, 3]);
+ * // => 3
+ *
+ * _.size({ 'a': 1, 'b': 2 });
+ * // => 2
+ *
+ * _.size('pebbles');
+ * // => 7
+ */function size(collection){if(collection==null){return 0}if(isArrayLike(collection)){return isString(collection)?stringSize(collection):collection.length}var tag=getTag(collection);if(tag==mapTag||tag==setTag){return collection.size}return baseKeys(collection).length}module.exports=size},{"./_baseKeys":106,"./_getTag":168,"./_stringSize":221,"./isArrayLike":244,"./isString":255}],276:[function(require,module,exports){var baseFlatten=require("./_baseFlatten"),baseOrderBy=require("./_baseOrderBy"),baseRest=require("./_baseRest"),isIterateeCall=require("./_isIterateeCall");
+/**
+ * Creates an array of elements, sorted in ascending order by the results of
+ * running each element in a collection thru each iteratee. This method
+ * performs a stable sort, that is, it preserves the original sort order of
+ * equal elements. The iteratees are invoked with one argument: (value).
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Collection
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {...(Function|Function[])} [iteratees=[_.identity]]
+ * The iteratees to sort by.
+ * @returns {Array} Returns the new sorted array.
+ * @example
+ *
+ * var users = [
+ * { 'user': 'fred', 'age': 48 },
+ * { 'user': 'barney', 'age': 36 },
+ * { 'user': 'fred', 'age': 40 },
+ * { 'user': 'barney', 'age': 34 }
+ * ];
+ *
+ * _.sortBy(users, [function(o) { return o.user; }]);
+ * // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 40]]
+ *
+ * _.sortBy(users, ['user', 'age']);
+ * // => objects for [['barney', 34], ['barney', 36], ['fred', 40], ['fred', 48]]
+ */var sortBy=baseRest(function(collection,iteratees){if(collection==null){return[]}var length=iteratees.length;if(length>1&&isIterateeCall(collection,iteratees[0],iteratees[1])){iteratees=[]}else if(length>2&&isIterateeCall(iteratees[0],iteratees[1],iteratees[2])){iteratees=[iteratees[0]]}return baseOrderBy(collection,baseFlatten(iteratees,1),[])});module.exports=sortBy},{"./_baseFlatten":86,"./_baseOrderBy":114,"./_baseRest":121,"./_isIterateeCall":182}],277:[function(require,module,exports){
+/**
+ * This method returns a new empty array.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.13.0
+ * @category Util
+ * @returns {Array} Returns the new empty array.
+ * @example
+ *
+ * var arrays = _.times(2, _.stubArray);
+ *
+ * console.log(arrays);
+ * // => [[], []]
+ *
+ * console.log(arrays[0] === arrays[1]);
+ * // => false
+ */
+function stubArray(){return[]}module.exports=stubArray},{}],278:[function(require,module,exports){
+/**
+ * This method returns `false`.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.13.0
+ * @category Util
+ * @returns {boolean} Returns `false`.
+ * @example
+ *
+ * _.times(2, _.stubFalse);
+ * // => [false, false]
+ */
+function stubFalse(){return false}module.exports=stubFalse},{}],279:[function(require,module,exports){var toNumber=require("./toNumber");
+/** Used as references for various `Number` constants. */var INFINITY=1/0,MAX_INTEGER=17976931348623157e292;
+/**
+ * Converts `value` to a finite number.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.12.0
+ * @category Lang
+ * @param {*} value The value to convert.
+ * @returns {number} Returns the converted number.
+ * @example
+ *
+ * _.toFinite(3.2);
+ * // => 3.2
+ *
+ * _.toFinite(Number.MIN_VALUE);
+ * // => 5e-324
+ *
+ * _.toFinite(Infinity);
+ * // => 1.7976931348623157e+308
+ *
+ * _.toFinite('3.2');
+ * // => 3.2
+ */function toFinite(value){if(!value){return value===0?value:0}value=toNumber(value);if(value===INFINITY||value===-INFINITY){var sign=value<0?-1:1;return sign*MAX_INTEGER}return value===value?value:0}module.exports=toFinite},{"./toNumber":281}],280:[function(require,module,exports){var toFinite=require("./toFinite");
+/**
+ * Converts `value` to an integer.
+ *
+ * **Note:** This method is loosely based on
+ * [`ToInteger`](http://www.ecma-international.org/ecma-262/7.0/#sec-tointeger).
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to convert.
+ * @returns {number} Returns the converted integer.
+ * @example
+ *
+ * _.toInteger(3.2);
+ * // => 3
+ *
+ * _.toInteger(Number.MIN_VALUE);
+ * // => 0
+ *
+ * _.toInteger(Infinity);
+ * // => 1.7976931348623157e+308
+ *
+ * _.toInteger('3.2');
+ * // => 3
+ */function toInteger(value){var result=toFinite(value),remainder=result%1;return result===result?remainder?result-remainder:result:0}module.exports=toInteger},{"./toFinite":279}],281:[function(require,module,exports){var isObject=require("./isObject"),isSymbol=require("./isSymbol");
+/** Used as references for various `Number` constants. */var NAN=0/0;
+/** Used to match leading and trailing whitespace. */var reTrim=/^\s+|\s+$/g;
+/** Used to detect bad signed hexadecimal string values. */var reIsBadHex=/^[-+]0x[0-9a-f]+$/i;
+/** Used to detect binary string values. */var reIsBinary=/^0b[01]+$/i;
+/** Used to detect octal string values. */var reIsOctal=/^0o[0-7]+$/i;
+/** Built-in method references without a dependency on `root`. */var freeParseInt=parseInt;
+/**
+ * Converts `value` to a number.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to process.
+ * @returns {number} Returns the number.
+ * @example
+ *
+ * _.toNumber(3.2);
+ * // => 3.2
+ *
+ * _.toNumber(Number.MIN_VALUE);
+ * // => 5e-324
+ *
+ * _.toNumber(Infinity);
+ * // => Infinity
+ *
+ * _.toNumber('3.2');
+ * // => 3.2
+ */function toNumber(value){if(typeof value=="number"){return value}if(isSymbol(value)){return NAN}if(isObject(value)){var other=typeof value.valueOf=="function"?value.valueOf():value;value=isObject(other)?other+"":other}if(typeof value!="string"){return value===0?value:+value}value=value.replace(reTrim,"");var isBinary=reIsBinary.test(value);return isBinary||reIsOctal.test(value)?freeParseInt(value.slice(2),isBinary?2:8):reIsBadHex.test(value)?NAN:+value}module.exports=toNumber},{"./isObject":251,"./isSymbol":256}],282:[function(require,module,exports){var copyObject=require("./_copyObject"),keysIn=require("./keysIn");
+/**
+ * Converts `value` to a plain object flattening inherited enumerable string
+ * keyed properties of `value` to own properties of the plain object.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category Lang
+ * @param {*} value The value to convert.
+ * @returns {Object} Returns the converted plain object.
+ * @example
+ *
+ * function Foo() {
+ * this.b = 2;
+ * }
+ *
+ * Foo.prototype.c = 3;
+ *
+ * _.assign({ 'a': 1 }, new Foo);
+ * // => { 'a': 1, 'b': 2 }
+ *
+ * _.assign({ 'a': 1 }, _.toPlainObject(new Foo));
+ * // => { 'a': 1, 'b': 2, 'c': 3 }
+ */function toPlainObject(value){return copyObject(value,keysIn(value))}module.exports=toPlainObject},{"./_copyObject":143,"./keysIn":260}],283:[function(require,module,exports){var baseToString=require("./_baseToString");
+/**
+ * Converts `value` to a string. An empty string is returned for `null`
+ * and `undefined` values. The sign of `-0` is preserved.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to convert.
+ * @returns {string} Returns the converted string.
+ * @example
+ *
+ * _.toString(null);
+ * // => ''
+ *
+ * _.toString(-0);
+ * // => '-0'
+ *
+ * _.toString([1, 2, 3]);
+ * // => '1,2,3'
+ */function toString(value){return value==null?"":baseToString(value)}module.exports=toString},{"./_baseToString":126}],284:[function(require,module,exports){var arrayEach=require("./_arrayEach"),baseCreate=require("./_baseCreate"),baseForOwn=require("./_baseForOwn"),baseIteratee=require("./_baseIteratee"),getPrototype=require("./_getPrototype"),isArray=require("./isArray"),isBuffer=require("./isBuffer"),isFunction=require("./isFunction"),isObject=require("./isObject"),isTypedArray=require("./isTypedArray");
+/**
+ * An alternative to `_.reduce`; this method transforms `object` to a new
+ * `accumulator` object which is the result of running each of its own
+ * enumerable string keyed properties thru `iteratee`, with each invocation
+ * potentially mutating the `accumulator` object. If `accumulator` is not
+ * provided, a new object with the same `[[Prototype]]` will be used. The
+ * iteratee is invoked with four arguments: (accumulator, value, key, object).
+ * Iteratee functions may exit iteration early by explicitly returning `false`.
+ *
+ * @static
+ * @memberOf _
+ * @since 1.3.0
+ * @category Object
+ * @param {Object} object The object to iterate over.
+ * @param {Function} [iteratee=_.identity] The function invoked per iteration.
+ * @param {*} [accumulator] The custom accumulator value.
+ * @returns {*} Returns the accumulated value.
+ * @example
+ *
+ * _.transform([2, 3, 4], function(result, n) {
+ * result.push(n *= n);
+ * return n % 2 == 0;
+ * }, []);
+ * // => [4, 9]
+ *
+ * _.transform({ 'a': 1, 'b': 2, 'c': 1 }, function(result, value, key) {
+ * (result[value] || (result[value] = [])).push(key);
+ * }, {});
+ * // => { '1': ['a', 'c'], '2': ['b'] }
+ */function transform(object,iteratee,accumulator){var isArr=isArray(object),isArrLike=isArr||isBuffer(object)||isTypedArray(object);iteratee=baseIteratee(iteratee,4);if(accumulator==null){var Ctor=object&&object.constructor;if(isArrLike){accumulator=isArr?new Ctor:[]}else if(isObject(object)){accumulator=isFunction(Ctor)?baseCreate(getPrototype(object)):{}}else{accumulator={}}}(isArrLike?arrayEach:baseForOwn)(object,function(value,index,object){return iteratee(accumulator,value,index,object)});return accumulator}module.exports=transform},{"./_arrayEach":64,"./_baseCreate":81,"./_baseForOwn":88,"./_baseIteratee":105,"./_getPrototype":164,"./isArray":243,"./isBuffer":246,"./isFunction":248,"./isObject":251,"./isTypedArray":257}],285:[function(require,module,exports){var baseFlatten=require("./_baseFlatten"),baseRest=require("./_baseRest"),baseUniq=require("./_baseUniq"),isArrayLikeObject=require("./isArrayLikeObject");
+/**
+ * Creates an array of unique values, in order, from all given arrays using
+ * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
+ * for equality comparisons.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Array
+ * @param {...Array} [arrays] The arrays to inspect.
+ * @returns {Array} Returns the new array of combined values.
+ * @example
+ *
+ * _.union([2], [1, 2]);
+ * // => [2, 1]
+ */var union=baseRest(function(arrays){return baseUniq(baseFlatten(arrays,1,isArrayLikeObject,true))});module.exports=union},{"./_baseFlatten":86,"./_baseRest":121,"./_baseUniq":128,"./isArrayLikeObject":245}],286:[function(require,module,exports){var toString=require("./toString");
+/** Used to generate unique IDs. */var idCounter=0;
+/**
+ * Generates a unique ID. If `prefix` is given, the ID is appended to it.
+ *
+ * @static
+ * @since 0.1.0
+ * @memberOf _
+ * @category Util
+ * @param {string} [prefix=''] The value to prefix the ID with.
+ * @returns {string} Returns the unique ID.
+ * @example
+ *
+ * _.uniqueId('contact_');
+ * // => 'contact_104'
+ *
+ * _.uniqueId();
+ * // => '105'
+ */function uniqueId(prefix){var id=++idCounter;return toString(prefix)+id}module.exports=uniqueId},{"./toString":283}],287:[function(require,module,exports){var baseValues=require("./_baseValues"),keys=require("./keys");
+/**
+ * Creates an array of the own enumerable string keyed property values of `object`.
+ *
+ * **Note:** Non-object values are coerced to objects.
+ *
+ * @static
+ * @since 0.1.0
+ * @memberOf _
+ * @category Object
+ * @param {Object} object The object to query.
+ * @returns {Array} Returns the array of property values.
+ * @example
+ *
+ * function Foo() {
+ * this.a = 1;
+ * this.b = 2;
+ * }
+ *
+ * Foo.prototype.c = 3;
+ *
+ * _.values(new Foo);
+ * // => [1, 2] (iteration order is not guaranteed)
+ *
+ * _.values('hi');
+ * // => ['h', 'i']
+ */function values(object){return object==null?[]:baseValues(object,keys(object))}module.exports=values},{"./_baseValues":129,"./keys":259}],288:[function(require,module,exports){var assignValue=require("./_assignValue"),baseZipObject=require("./_baseZipObject");
+/**
+ * This method is like `_.fromPairs` except that it accepts two arrays,
+ * one of property identifiers and one of corresponding values.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.4.0
+ * @category Array
+ * @param {Array} [props=[]] The property identifiers.
+ * @param {Array} [values=[]] The property values.
+ * @returns {Object} Returns the new object.
+ * @example
+ *
+ * _.zipObject(['a', 'b'], [1, 2]);
+ * // => { 'a': 1, 'b': 2 }
+ */function zipObject(props,values){return baseZipObject(props||[],values||[],assignValue)}module.exports=zipObject},{"./_assignValue":75,"./_baseZipObject":130}]},{},[1])(1)});
diff --git a/js/kundenkarte_cytoscape.js b/js/kundenkarte_cytoscape.js
new file mode 100644
index 0000000..e96c2dd
--- /dev/null
+++ b/js/kundenkarte_cytoscape.js
@@ -0,0 +1,850 @@
+/**
+ * KundenKarte Graph-Ansicht (Cytoscape.js)
+ * Hierarchisches Top-Down Layout (dagre)
+ * Gebäude-Typen als Container, Geräte darin, Kabel als Verbindungen
+ * Keine Pfeile - Stromleitungen haben keine Richtung
+ *
+ * Copyright (C) 2026 Alles Watt lauft
+ */
+(function() {
+ 'use strict';
+
+ window.KundenKarte = window.KundenKarte || {};
+
+ // FontAwesome 5 Unicode-Mapping für Cytoscape-Labels
+ var FA_ICONS = {
+ 'fa-home': '\uf015',
+ 'fa-building': '\uf1ad',
+ 'fa-warehouse': '\uf494',
+ 'fa-compass': '\uf14e',
+ 'fa-utensils': '\uf2e7',
+ 'fa-bed': '\uf236',
+ 'fa-bath': '\uf2cd',
+ 'fa-car': '\uf1b9',
+ 'fa-car-side': '\uf5e4',
+ 'fa-tree': '\uf1bb',
+ 'fa-leaf': '\uf06c',
+ 'fa-sun': '\uf185',
+ 'fa-child': '\uf1ae',
+ 'fa-desktop': '\uf108',
+ 'fa-server': '\uf233',
+ 'fa-cogs': '\uf085',
+ 'fa-tools': '\uf7d9',
+ 'fa-box': '\uf466',
+ 'fa-door-open': '\uf52b',
+ 'fa-door-closed': '\uf52a',
+ 'fa-square': '\uf0c8',
+ 'fa-charging-station': '\uf5e7',
+ 'fa-database': '\uf1c0',
+ 'fa-fire': '\uf06d',
+ 'fa-solar-panel': '\uf5ba',
+ 'fa-tachometer-alt': '\uf3fd',
+ 'fa-th-list': '\uf00b',
+ 'fa-bolt': '\uf0e7',
+ 'fa-plus-square': '\uf0fe',
+ 'fa-level-down-alt': '\uf3be',
+ 'fa-level-up-alt': '\uf3bf',
+ 'fa-layer-group': '\uf5fd',
+ 'fa-arrows-alt-h': '\uf337',
+ 'fa-tshirt': '\uf553',
+ 'fa-mountain': '\uf6fc',
+ 'fa-horse': '\uf6f0',
+ 'fa-toilet': '\uf7d8',
+ 'fa-couch': '\uf4b8',
+ 'fa-plug': '\uf1e6',
+ 'fa-sitemap': '\uf0e8'
+ };
+
+ KundenKarte.Graph = {
+ cy: null,
+ containerId: 'kundenkarte-graph-container',
+ ajaxUrl: '',
+ saveUrl: '',
+ moduleUrl: '',
+ socId: 0,
+ contactId: 0,
+ isContact: false,
+ tooltipEl: null,
+ wheelZoomEnabled: false,
+ hasPositions: false,
+ _saveTimer: null,
+ _dirtyNodes: {},
+ _viewportTimer: null,
+
+ /**
+ * Initialisierung
+ */
+ init: function(config) {
+ this.socId = config.socId || 0;
+ this.contactId = config.contactId || 0;
+ this.isContact = config.isContact || false;
+
+ this.createTooltipElement();
+ this.bindZoomButtons();
+ this.loadGraphData();
+ },
+
+ /**
+ * FontAwesome-Klasse in Unicode-Zeichen umwandeln
+ */
+ getIconChar: function(picto) {
+ if (!picto) return '';
+ var parts = picto.split(' ');
+ for (var i = 0; i < parts.length; i++) {
+ if (parts[i].indexOf('fa-') === 0 && FA_ICONS[parts[i]]) {
+ return FA_ICONS[parts[i]];
+ }
+ }
+ return '';
+ },
+
+ /**
+ * Tooltip-Element erzeugen
+ */
+ createTooltipElement: function() {
+ this.tooltipEl = document.createElement('div');
+ this.tooltipEl.className = 'kundenkarte-graph-tooltip';
+ this.tooltipEl.style.display = 'none';
+ document.body.appendChild(this.tooltipEl);
+ },
+
+ /**
+ * Daten vom Server laden
+ */
+ loadGraphData: function() {
+ var self = this;
+ var url = this.ajaxUrl + '?socid=' + this.socId;
+ if (this.contactId > 0) {
+ url += '&contactid=' + this.contactId;
+ }
+
+ $.ajax({
+ url: url,
+ type: 'GET',
+ dataType: 'json',
+ success: function(response) {
+ $('#' + self.containerId + ' .kundenkarte-graph-loading').remove();
+
+ if (response.success) {
+ if (response.elements.nodes.length === 0) {
+ self.showEmpty();
+ } else {
+ self.hasPositions = !!response.has_positions;
+ try {
+ self.renderGraph(response.elements);
+ } catch(e) {
+ console.error('KundenKarte Graph Fehler:', e);
+ }
+ // Legende IMMER rendern (auch bei Graph-Fehler)
+ self.renderLegend(response.cable_types || []);
+ }
+ } else {
+ if (typeof KundenKarte.showError === 'function') {
+ KundenKarte.showError('Fehler', response.error || 'Daten konnten nicht geladen werden');
+ }
+ }
+ },
+ error: function() {
+ $('#' + self.containerId + ' .kundenkarte-graph-loading').remove();
+ if (typeof KundenKarte.showError === 'function') {
+ KundenKarte.showError('Fehler', 'Netzwerkfehler beim Laden der Graph-Daten');
+ }
+ }
+ });
+ },
+
+ /**
+ * Leeren Zustand anzeigen
+ */
+ showEmpty: function() {
+ $('#' + this.containerId).html(
+ '' +
+ '' +
+ 'Keine Elemente vorhanden' +
+ '
'
+ );
+ },
+
+ /**
+ * Dynamische Legende rendern (Gebäude + Geräte + Kabeltypen)
+ */
+ renderLegend: function(cableTypes) {
+ var $legend = $('#kundenkarte-graph-legend');
+ if (!$legend.length) return;
+
+ var html = '';
+ // Feste Einträge: Raum + Gerät
+ html += '';
+ html += ' Raum/Gebäude';
+ html += '';
+ html += ' Gerät';
+
+ // Dynamische Kabeltypen mit Farben
+ if (cableTypes && cableTypes.length > 0) {
+ for (var i = 0; i < cableTypes.length; i++) {
+ var ct = cableTypes[i];
+ html += '';
+ html += ' ';
+ html += this.escapeHtml(ct.label) + '';
+ }
+ }
+
+ // Durchgeschleift (immer anzeigen)
+ html += '';
+ html += ' Durchgeschleift';
+
+ $legend.html(html);
+ },
+
+ /**
+ * Rastergröße für Snap-to-Grid (unsichtbar)
+ */
+ gridSize: 20,
+
+ /**
+ * Maximaler Zoom beim Einpassen (verhindert zu starkes Reinzoomen)
+ */
+ maxFitZoom: 0.85,
+
+ /**
+ * LocalStorage-Key für Viewport-State
+ */
+ _viewportKey: function() {
+ return 'kundenkarte_graph_vp_' + this.socId + '_' + this.contactId;
+ },
+
+ /**
+ * Viewport (Zoom + Pan) im localStorage speichern
+ */
+ saveViewport: function() {
+ if (!this.cy) return;
+ try {
+ localStorage.setItem(this._viewportKey(), JSON.stringify({
+ zoom: this.cy.zoom(),
+ pan: this.cy.pan()
+ }));
+ } catch(e) { /* localStorage voll/nicht verfügbar */ }
+ },
+
+ /**
+ * Viewport aus localStorage wiederherstellen
+ * @return {boolean} true wenn wiederhergestellt
+ */
+ restoreViewport: function() {
+ if (!this.cy) return false;
+ try {
+ var saved = localStorage.getItem(this._viewportKey());
+ if (saved) {
+ var vp = JSON.parse(saved);
+ this.cy.viewport({ zoom: vp.zoom, pan: vp.pan });
+ return true;
+ }
+ } catch(e) { /* ungültige Daten */ }
+ return false;
+ },
+
+ /**
+ * Graph rendern
+ */
+ renderGraph: function(elements) {
+ var self = this;
+
+ // Labels zusammenbauen: Name + Klammer-Felder + Badge-Felder
+ var cyElements = [];
+ if (elements.nodes) {
+ elements.nodes.forEach(function(n) {
+ var icon = self.getIconChar(n.data.type_picto);
+ var namePart = icon ? (icon + ' ' + n.data.label) : n.data.label;
+
+ if (n.data.is_building) {
+ // Gebäude: Icon + Name + evtl. Klammer-Felder
+ var parens = [];
+ if (n.data.fields) {
+ for (var i = 0; i < n.data.fields.length; i++) {
+ var f = n.data.fields[i];
+ if (f.display === 'parentheses' && f.value) {
+ parens.push(f.value);
+ }
+ }
+ }
+ n.data.display_label = parens.length > 0
+ ? namePart + ' (' + parens.join(', ') + ')'
+ : namePart;
+ } else {
+ // Gerät: Name (+ Klammer-Felder) + Trennlinie + Badge-Felder
+ var parenParts = [];
+ var badgeLines = [];
+
+ if (n.data.fields) {
+ for (var i = 0; i < n.data.fields.length; i++) {
+ var f = n.data.fields[i];
+ var v = f.value;
+ if (!v || v === '') continue;
+ if (v === '1' && f.display === 'badge') v = '\u2713';
+
+ if (f.display === 'parentheses') {
+ parenParts.push(v);
+ } else if (f.display === 'badge') {
+ badgeLines.push(f.label + ': ' + v);
+ }
+ }
+ }
+
+ var lines = [];
+ // Zeile 1: Name + Klammer-Werte
+ if (parenParts.length > 0) {
+ lines.push(namePart + ' (' + parenParts.join(', ') + ')');
+ } else {
+ lines.push(namePart);
+ }
+ // Badge-Felder als Karten-Zeilen
+ if (badgeLines.length > 0) {
+ lines.push('─────────────');
+ for (var j = 0; j < badgeLines.length; j++) {
+ lines.push(badgeLines[j]);
+ }
+ }
+
+ n.data.display_label = lines.join('\n');
+ }
+
+ cyElements.push(n);
+ });
+ }
+ if (elements.edges) {
+ elements.edges.forEach(function(e) { cyElements.push(e); });
+ }
+
+ // Einpassen, aber nicht über maxFitZoom hinaus zoomen
+ var fitWithLimit = function(cy) {
+ cy.fit(undefined, 50);
+ if (cy.zoom() > self.maxFitZoom) {
+ cy.zoom(self.maxFitZoom);
+ cy.center();
+ }
+ };
+
+ // Container-Höhe an Inhalt anpassen
+ var autoResizeContainer = function(cy) {
+ var bb = cy.elements().boundingBox();
+ if (!bb || bb.w === 0) return;
+ // Benötigte Höhe bei aktuellem Zoom + Padding
+ var neededHeight = (bb.h * cy.zoom()) + 100;
+ var container = document.getElementById(self.containerId);
+ var minH = 300;
+ var maxH = window.innerHeight * 0.8;
+ var newH = Math.max(minH, Math.min(maxH, neededHeight));
+ if (Math.abs(newH - container.clientHeight) > 20) {
+ container.style.height = Math.round(newH) + 'px';
+ cy.resize();
+ }
+ };
+
+ // Cytoscape-Instanz erstellen (ohne Layout - wird separat gestartet)
+ this.cy = cytoscape({
+ container: document.getElementById(this.containerId),
+ elements: cyElements,
+ style: this.getStylesheet(),
+ minZoom: 0.15,
+ maxZoom: 4,
+ userZoomingEnabled: false,
+ userPanningEnabled: true,
+ boxSelectionEnabled: false,
+ layout: { name: 'preset' }
+ });
+
+ // dagre-Layout NACH Instanz-Erstellung starten (self.cy ist jetzt gesetzt)
+ this.cy.layout({
+ name: 'dagre',
+ rankDir: 'TB',
+ nodeSep: 50,
+ rankSep: 80,
+ fit: false,
+ stop: function() {
+ if (self.hasPositions) {
+ // Gespeicherte Positionen anwenden
+ self.cy.nodes().forEach(function(node) {
+ var d = node.data();
+ if (d.graph_x !== null && d.graph_y !== null) {
+ node.position({ x: d.graph_x, y: d.graph_y });
+ }
+ });
+ // Container an Inhalt anpassen, dann Viewport wiederherstellen
+ autoResizeContainer(self.cy);
+ if (!self.restoreViewport()) {
+ fitWithLimit(self.cy);
+ }
+ } else {
+ // Kein gespeichertes Layout: dagre-Ergebnis einpassen
+ autoResizeContainer(self.cy);
+ fitWithLimit(self.cy);
+ }
+ }
+ }).run();
+
+ this.bindGraphEvents();
+ },
+
+ /**
+ * Cytoscape Stylesheet
+ */
+ getStylesheet: function() {
+ var faFont = '"Font Awesome 5 Free", "FontAwesome", sans-serif';
+
+ return [
+ // Räume/Gebäude (Compound-Container)
+ {
+ selector: '.building-node',
+ style: {
+ 'shape': 'roundrectangle',
+ 'background-color': '#2a2b2d',
+ 'background-opacity': 1,
+ 'border-width': 2,
+ 'border-color': '#4390dc',
+ 'border-style': 'dashed',
+ 'padding': '25px',
+ 'label': 'data(display_label)',
+ 'font-family': faFont,
+ 'font-weight': 'bold',
+ 'text-valign': 'top',
+ 'text-halign': 'center',
+ 'font-size': '13px',
+ 'color': '#ffffff',
+ 'text-margin-y': -8,
+ 'text-background-color': '#2a2b2d',
+ 'text-background-opacity': 0.95,
+ 'text-background-padding': '4px',
+ 'text-background-shape': 'roundrectangle',
+ 'min-width': '120px',
+ 'min-height': '60px'
+ }
+ },
+ // Geräte - Karten-Design mit Feldwerten
+ {
+ selector: '.device-node',
+ style: {
+ 'shape': 'roundrectangle',
+ 'width': 'label',
+ 'height': 'label',
+ 'padding': '14px',
+ 'background-color': '#2d4a3a',
+ 'border-width': 2,
+ 'border-color': '#5a9a6a',
+ 'label': 'data(display_label)',
+ 'font-family': faFont,
+ 'font-weight': 'bold',
+ 'text-valign': 'center',
+ 'text-halign': 'center',
+ 'text-justification': 'left',
+ 'font-size': '11px',
+ 'color': '#ffffff',
+ 'text-wrap': 'wrap',
+ 'text-max-width': '220px',
+ 'line-height': 1.4
+ }
+ },
+ // Kabel - Farbe aus medium_color, Fallback grün
+ {
+ selector: '.cable-edge',
+ style: {
+ 'width': 3,
+ 'line-color': function(edge) {
+ return edge.data('medium_color') || '#5a8a5a';
+ },
+ 'target-arrow-shape': 'none',
+ 'source-arrow-shape': 'none',
+ 'curve-style': 'bezier',
+ 'label': 'data(label)',
+ 'font-size': '9px',
+ 'color': '#8a9aa8',
+ 'text-rotation': 'autorotate',
+ 'text-background-color': '#1a2030',
+ 'text-background-opacity': 0.85,
+ 'text-background-padding': '3px',
+ 'text-background-shape': 'roundrectangle'
+ }
+ },
+ // Durchgeschleifte Leitungen - gestrichelt
+ {
+ selector: '.passthrough-edge',
+ style: {
+ 'width': 1,
+ 'line-color': '#505860',
+ 'line-style': 'dashed',
+ 'target-arrow-shape': 'none',
+ 'source-arrow-shape': 'none',
+ 'curve-style': 'bezier'
+ }
+ },
+ // Hover
+ {
+ selector: 'node:active',
+ style: {
+ 'overlay-opacity': 0.1,
+ 'overlay-color': '#7ab0d4'
+ }
+ },
+ // Selektiert
+ {
+ selector: ':selected',
+ style: {
+ 'border-color': '#d4944a',
+ 'border-width': 3
+ }
+ }
+ ];
+ },
+
+ /**
+ * Graph-Events binden
+ */
+ bindGraphEvents: function() {
+ var self = this;
+
+ // Tap auf Geräte-Node -> Detail-Ansicht
+ this.cy.on('tap', 'node.device-node', function(evt) {
+ var node = evt.target;
+ var anlageId = node.data('id').replace('n_', '');
+ var url;
+ if (self.isContact && self.contactId > 0) {
+ url = self.moduleUrl + '/tabs/contact_anlagen.php?id=' + self.contactId
+ + '&action=view&anlage_id=' + anlageId;
+ } else {
+ url = self.moduleUrl + '/tabs/anlagen.php?id=' + self.socId
+ + '&action=view&anlage_id=' + anlageId;
+ }
+ window.location.href = url;
+ });
+
+ // Tap auf Kabel-Edge -> Verbindungs-Editor
+ this.cy.on('tap', 'edge.cable-edge', function(evt) {
+ var edge = evt.target;
+ var connId = edge.data('connection_id');
+ if (connId) {
+ window.location.href = self.moduleUrl + '/anlage_connection.php?id=' + connId + '&action=edit';
+ }
+ });
+
+ // Mouseover Tooltip
+ this.cy.on('mouseover', 'node', function(evt) {
+ self.showNodeTooltip(evt.target, evt.renderedPosition);
+ });
+ this.cy.on('mouseout', 'node', function() {
+ self.hideTooltip();
+ });
+ this.cy.on('mouseover', 'edge.cable-edge', function(evt) {
+ self.showEdgeTooltip(evt.target, evt.renderedPosition);
+ });
+ this.cy.on('mouseout', 'edge', function() {
+ self.hideTooltip();
+ });
+
+ // Drag: Begrenzung auf sichtbaren Bereich
+ this.cy.on('drag', 'node', function(evt) {
+ var node = evt.target;
+ var pos = node.position();
+ var ext = self.cy.extent();
+ // Etwas Rand lassen damit Node nicht am Rand klebt
+ var margin = 20;
+ var clampedX = Math.max(ext.x1 + margin, Math.min(ext.x2 - margin, pos.x));
+ var clampedY = Math.max(ext.y1 + margin, Math.min(ext.y2 - margin, pos.y));
+ if (clampedX !== pos.x || clampedY !== pos.y) {
+ node.position({ x: clampedX, y: clampedY });
+ }
+ });
+
+ // Drag: Snap-to-Grid + Position merken (inkl. Kinder bei Compound-Nodes)
+ this.cy.on('dragfree', 'node', function(evt) {
+ var node = evt.target;
+ var pos = node.position();
+ var grid = self.gridSize;
+
+ // Auf Raster einrasten
+ var snappedX = Math.round(pos.x / grid) * grid;
+ var snappedY = Math.round(pos.y / grid) * grid;
+ node.position({ x: snappedX, y: snappedY });
+
+ // Position zum Speichern vormerken
+ var anlageId = node.data('id').replace('n_', '');
+ self._dirtyNodes[anlageId] = { id: parseInt(anlageId), x: snappedX, y: snappedY };
+
+ // Bei Compound-Nodes auch alle Kinder speichern
+ var children = node.children();
+ if (children.length > 0) {
+ children.forEach(function(child) {
+ var childPos = child.position();
+ var childId = child.data('id').replace('n_', '');
+ self._dirtyNodes[childId] = { id: parseInt(childId), x: childPos.x, y: childPos.y };
+ // Rekursiv für verschachtelte Compounds
+ child.children().forEach(function(grandchild) {
+ var gcPos = grandchild.position();
+ var gcId = grandchild.data('id').replace('n_', '');
+ self._dirtyNodes[gcId] = { id: parseInt(gcId), x: gcPos.x, y: gcPos.y };
+ });
+ });
+ }
+
+ // Debounced speichern (500ms nach letztem Drag)
+ if (self._saveTimer) clearTimeout(self._saveTimer);
+ self._saveTimer = setTimeout(function() {
+ self.savePositions();
+ }, 500);
+ });
+
+ // Viewport-Änderungen speichern (Pan + Zoom)
+ this.cy.on('viewport', function() {
+ if (self._viewportTimer) clearTimeout(self._viewportTimer);
+ self._viewportTimer = setTimeout(function() {
+ self.saveViewport();
+ }, 300);
+ });
+
+ // Cursor
+ this.cy.on('mouseover', 'node.device-node, edge.cable-edge', function() {
+ document.getElementById(self.containerId).style.cursor = 'pointer';
+ });
+ this.cy.on('mouseout', 'node, edge', function() {
+ document.getElementById(self.containerId).style.cursor = 'default';
+ });
+ },
+
+ /**
+ * Zoom-Buttons binden
+ */
+ bindZoomButtons: function() {
+ var self = this;
+
+ // Mausrad-Zoom Ein/Aus
+ $(document).on('click', '#btn-graph-wheel-zoom', function(e) {
+ e.preventDefault();
+ self.wheelZoomEnabled = !self.wheelZoomEnabled;
+ if (self.cy) {
+ self.cy.userZoomingEnabled(self.wheelZoomEnabled);
+ }
+ $(this).toggleClass('active', self.wheelZoomEnabled);
+ $(this).attr('title', self.wheelZoomEnabled ? 'Mausrad-Zoom aus' : 'Mausrad-Zoom ein');
+ });
+
+ $(document).on('click', '#btn-graph-fit', function(e) {
+ e.preventDefault();
+ if (self.cy) {
+ self.cy.zoom(self.maxFitZoom);
+ self.cy.center();
+ }
+ });
+ $(document).on('click', '#btn-graph-zoom-in', function(e) {
+ e.preventDefault();
+ if (self.cy) {
+ self.cy.zoom({
+ level: self.cy.zoom() * 1.3,
+ renderedPosition: { x: self.cy.width() / 2, y: self.cy.height() / 2 }
+ });
+ }
+ });
+ $(document).on('click', '#btn-graph-zoom-out', function(e) {
+ e.preventDefault();
+ if (self.cy) {
+ self.cy.zoom({
+ level: self.cy.zoom() / 1.3,
+ renderedPosition: { x: self.cy.width() / 2, y: self.cy.height() / 2 }
+ });
+ }
+ });
+
+ // Layout zurücksetzen
+ $(document).on('click', '#btn-graph-reset-layout', function(e) {
+ e.preventDefault();
+ self.resetLayout();
+ });
+ },
+
+ /**
+ * Geänderte Positionen an Server senden
+ */
+ savePositions: function() {
+ var positions = [];
+ for (var id in this._dirtyNodes) {
+ positions.push(this._dirtyNodes[id]);
+ }
+ if (positions.length === 0) return;
+
+ // Dirty-Liste leeren
+ this._dirtyNodes = {};
+
+ $.ajax({
+ url: this.saveUrl + '?action=save',
+ type: 'POST',
+ contentType: 'application/json',
+ data: JSON.stringify({ positions: positions }),
+ dataType: 'json',
+ success: function(resp) {
+ if (!resp.success) {
+ console.error('Graph-Positionen speichern fehlgeschlagen:', resp.error);
+ }
+ },
+ error: function(xhr, status, err) {
+ console.error('Graph-Positionen Netzwerkfehler:', status, err);
+ }
+ });
+ },
+
+ /**
+ * Layout zurücksetzen: Positionen löschen + dagre neu berechnen
+ */
+ resetLayout: function() {
+ if (!this.cy) return;
+ var self = this;
+
+ // Positionen in DB + Viewport in localStorage löschen
+ $.ajax({
+ url: this.saveUrl + '?action=reset&socid=' + this.socId +
+ (this.contactId > 0 ? '&contactid=' + this.contactId : ''),
+ type: 'POST',
+ dataType: 'json'
+ });
+ try { localStorage.removeItem(this._viewportKey()); } catch(e) {}
+
+ // dagre Layout neu berechnen
+ this.hasPositions = false;
+ this._dirtyNodes = {};
+ var cy = this.cy;
+ var maxZoom = this.maxFitZoom;
+ cy.layout({
+ name: 'dagre',
+ rankDir: 'TB',
+ nodeSep: 50,
+ rankSep: 80,
+ fit: false,
+ animate: true,
+ animationDuration: 400,
+ stop: function() {
+ // Container an neues Layout anpassen
+ var bb = cy.elements().boundingBox();
+ if (bb && bb.h > 0) {
+ var neededH = (bb.h * maxZoom) + 100;
+ var container = document.getElementById(self.containerId);
+ var minH = 300;
+ var maxH = window.innerHeight * 0.8;
+ var newH = Math.max(minH, Math.min(maxH, neededH));
+ container.style.height = Math.round(newH) + 'px';
+ cy.resize();
+ }
+ cy.fit(undefined, 50);
+ if (cy.zoom() > maxZoom) {
+ cy.zoom(maxZoom);
+ cy.center();
+ }
+ }
+ }).run();
+ },
+
+ /**
+ * Node-Tooltip
+ */
+ showNodeTooltip: function(node, position) {
+ var data = node.data();
+ // Überschrift: Icon + Bezeichnung
+ var html = '';
+ if (data.type_picto) {
+ html += ' ';
+ }
+ html += this.escapeHtml(data.label) + '
';
+
+ if (data.fields && data.fields.length > 0) {
+ for (var i = 0; i < data.fields.length && i < 10; i++) {
+ var f = data.fields[i];
+ if (!f.value || f.value === '') continue;
+ var val = f.value;
+ if (val === '1') val = '\u2713';
+ html += '';
+ html += '' + this.escapeHtml(f.label) + '';
+ if (f.display === 'badge') {
+ var bgColor = f.color || '#4a5568';
+ html += '' + this.escapeHtml(String(val)) + '';
+ } else {
+ html += '' + this.escapeHtml(String(val)) + '';
+ }
+ html += '
';
+ }
+ }
+
+ if (data.image_count > 0 || data.doc_count > 0) {
+ html += '';
+ if (data.image_count > 0) html += ' ' + data.image_count + ' ';
+ if (data.doc_count > 0) html += ' ' + data.doc_count;
+ html += '
';
+ }
+
+ this.tooltipEl.innerHTML = html;
+ this.tooltipEl.style.display = 'block';
+ this.positionTooltip(position);
+ },
+
+ /**
+ * Edge-Tooltip
+ */
+ showEdgeTooltip: function(edge, position) {
+ var data = edge.data();
+ var html = 'Verbindung
';
+ if (data.medium_type) {
+ html += 'Typ' + this.escapeHtml(data.medium_type) + '
';
+ }
+ if (data.medium_spec) {
+ html += 'Spezifikation' + this.escapeHtml(data.medium_spec) + '
';
+ }
+ if (data.medium_length) {
+ html += 'Länge' + this.escapeHtml(data.medium_length) + '
';
+ }
+ this.tooltipEl.innerHTML = html;
+ this.tooltipEl.style.display = 'block';
+ this.positionTooltip(position);
+ },
+
+ positionTooltip: function(renderedPos) {
+ var container = document.getElementById(this.containerId);
+ var rect = container.getBoundingClientRect();
+ var x = rect.left + renderedPos.x + 15;
+ var y = rect.top + renderedPos.y - 10 + window.scrollY;
+ if (x + 300 > window.innerWidth) {
+ x = rect.left + renderedPos.x - 315;
+ }
+ this.tooltipEl.style.left = x + 'px';
+ this.tooltipEl.style.top = y + 'px';
+ },
+
+ hideTooltip: function() {
+ if (this.tooltipEl) this.tooltipEl.style.display = 'none';
+ },
+
+ escapeHtml: function(str) {
+ if (!str) return '';
+ var div = document.createElement('div');
+ div.appendChild(document.createTextNode(str));
+ return div.innerHTML;
+ },
+
+ destroy: function() {
+ if (this.cy) { this.cy.destroy(); this.cy = null; }
+ if (this.tooltipEl && this.tooltipEl.parentNode) {
+ this.tooltipEl.parentNode.removeChild(this.tooltipEl);
+ this.tooltipEl = null;
+ }
+ }
+ };
+
+ // Auto-Init
+ $(document).ready(function() {
+ var container = document.getElementById('kundenkarte-graph-container');
+ if (container) {
+ KundenKarte.Graph.ajaxUrl = container.getAttribute('data-ajax-url') || '';
+ KundenKarte.Graph.saveUrl = container.getAttribute('data-save-url') || '';
+ KundenKarte.Graph.moduleUrl = container.getAttribute('data-module-url') || '';
+ KundenKarte.Graph.init({
+ socId: parseInt(container.getAttribute('data-socid')) || 0,
+ contactId: parseInt(container.getAttribute('data-contactid')) || 0,
+ isContact: container.hasAttribute('data-contactid') && parseInt(container.getAttribute('data-contactid')) > 0
+ });
+ }
+ });
+
+})();
diff --git a/js/layout-base.js b/js/layout-base.js
new file mode 100644
index 0000000..ebbf2c6
--- /dev/null
+++ b/js/layout-base.js
@@ -0,0 +1,5230 @@
+(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["layoutBase"] = factory();
+ else
+ root["layoutBase"] = 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] = {
+/******/ 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 = 28);
+/******/ })
+/************************************************************************/
+/******/ ([
+/* 0 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+function LayoutConstants() {}
+
+/**
+ * Layout Quality: 0:draft, 1:default, 2:proof
+ */
+LayoutConstants.QUALITY = 1;
+
+/**
+ * Default parameters
+ */
+LayoutConstants.DEFAULT_CREATE_BENDS_AS_NEEDED = false;
+LayoutConstants.DEFAULT_INCREMENTAL = false;
+LayoutConstants.DEFAULT_ANIMATION_ON_LAYOUT = true;
+LayoutConstants.DEFAULT_ANIMATION_DURING_LAYOUT = false;
+LayoutConstants.DEFAULT_ANIMATION_PERIOD = 50;
+LayoutConstants.DEFAULT_UNIFORM_LEAF_NODE_SIZES = false;
+
+// -----------------------------------------------------------------------------
+// Section: General other constants
+// -----------------------------------------------------------------------------
+/*
+ * Margins of a graph to be applied on bouding rectangle of its contents. We
+ * assume margins on all four sides to be uniform.
+ */
+LayoutConstants.DEFAULT_GRAPH_MARGIN = 15;
+
+/*
+ * Whether to consider labels in node dimensions or not
+ */
+LayoutConstants.NODE_DIMENSIONS_INCLUDE_LABELS = false;
+
+/*
+ * Default dimension of a non-compound node.
+ */
+LayoutConstants.SIMPLE_NODE_SIZE = 40;
+
+/*
+ * Default dimension of a non-compound node.
+ */
+LayoutConstants.SIMPLE_NODE_HALF_SIZE = LayoutConstants.SIMPLE_NODE_SIZE / 2;
+
+/*
+ * Empty compound node size. When a compound node is empty, its both
+ * dimensions should be of this value.
+ */
+LayoutConstants.EMPTY_COMPOUND_NODE_SIZE = 40;
+
+/*
+ * Minimum length that an edge should take during layout
+ */
+LayoutConstants.MIN_EDGE_LENGTH = 1;
+
+/*
+ * World boundaries that layout operates on
+ */
+LayoutConstants.WORLD_BOUNDARY = 1000000;
+
+/*
+ * World boundaries that random positioning can be performed with
+ */
+LayoutConstants.INITIAL_WORLD_BOUNDARY = LayoutConstants.WORLD_BOUNDARY / 1000;
+
+/*
+ * Coordinates of the world center
+ */
+LayoutConstants.WORLD_CENTER_X = 1200;
+LayoutConstants.WORLD_CENTER_Y = 900;
+
+module.exports = LayoutConstants;
+
+/***/ }),
+/* 1 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+var LGraphObject = __webpack_require__(2);
+var IGeometry = __webpack_require__(8);
+var IMath = __webpack_require__(9);
+
+function LEdge(source, target, vEdge) {
+ LGraphObject.call(this, vEdge);
+
+ this.isOverlapingSourceAndTarget = false;
+ this.vGraphObject = vEdge;
+ this.bendpoints = [];
+ this.source = source;
+ this.target = target;
+}
+
+LEdge.prototype = Object.create(LGraphObject.prototype);
+
+for (var prop in LGraphObject) {
+ LEdge[prop] = LGraphObject[prop];
+}
+
+LEdge.prototype.getSource = function () {
+ return this.source;
+};
+
+LEdge.prototype.getTarget = function () {
+ return this.target;
+};
+
+LEdge.prototype.isInterGraph = function () {
+ return this.isInterGraph;
+};
+
+LEdge.prototype.getLength = function () {
+ return this.length;
+};
+
+LEdge.prototype.isOverlapingSourceAndTarget = function () {
+ return this.isOverlapingSourceAndTarget;
+};
+
+LEdge.prototype.getBendpoints = function () {
+ return this.bendpoints;
+};
+
+LEdge.prototype.getLca = function () {
+ return this.lca;
+};
+
+LEdge.prototype.getSourceInLca = function () {
+ return this.sourceInLca;
+};
+
+LEdge.prototype.getTargetInLca = function () {
+ return this.targetInLca;
+};
+
+LEdge.prototype.getOtherEnd = function (node) {
+ if (this.source === node) {
+ return this.target;
+ } else if (this.target === node) {
+ return this.source;
+ } else {
+ throw "Node is not incident with this edge";
+ }
+};
+
+LEdge.prototype.getOtherEndInGraph = function (node, graph) {
+ var otherEnd = this.getOtherEnd(node);
+ var root = graph.getGraphManager().getRoot();
+
+ while (true) {
+ if (otherEnd.getOwner() == graph) {
+ return otherEnd;
+ }
+
+ if (otherEnd.getOwner() == root) {
+ break;
+ }
+
+ otherEnd = otherEnd.getOwner().getParent();
+ }
+
+ return null;
+};
+
+LEdge.prototype.updateLength = function () {
+ var clipPointCoordinates = new Array(4);
+
+ this.isOverlapingSourceAndTarget = IGeometry.getIntersection(this.target.getRect(), this.source.getRect(), clipPointCoordinates);
+
+ if (!this.isOverlapingSourceAndTarget) {
+ this.lengthX = clipPointCoordinates[0] - clipPointCoordinates[2];
+ this.lengthY = clipPointCoordinates[1] - clipPointCoordinates[3];
+
+ if (Math.abs(this.lengthX) < 1.0) {
+ this.lengthX = IMath.sign(this.lengthX);
+ }
+
+ if (Math.abs(this.lengthY) < 1.0) {
+ this.lengthY = IMath.sign(this.lengthY);
+ }
+
+ this.length = Math.sqrt(this.lengthX * this.lengthX + this.lengthY * this.lengthY);
+ }
+};
+
+LEdge.prototype.updateLengthSimple = function () {
+ this.lengthX = this.target.getCenterX() - this.source.getCenterX();
+ this.lengthY = this.target.getCenterY() - this.source.getCenterY();
+
+ if (Math.abs(this.lengthX) < 1.0) {
+ this.lengthX = IMath.sign(this.lengthX);
+ }
+
+ if (Math.abs(this.lengthY) < 1.0) {
+ this.lengthY = IMath.sign(this.lengthY);
+ }
+
+ this.length = Math.sqrt(this.lengthX * this.lengthX + this.lengthY * this.lengthY);
+};
+
+module.exports = LEdge;
+
+/***/ }),
+/* 2 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+function LGraphObject(vGraphObject) {
+ this.vGraphObject = vGraphObject;
+}
+
+module.exports = LGraphObject;
+
+/***/ }),
+/* 3 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+var LGraphObject = __webpack_require__(2);
+var Integer = __webpack_require__(10);
+var RectangleD = __webpack_require__(13);
+var LayoutConstants = __webpack_require__(0);
+var RandomSeed = __webpack_require__(16);
+var PointD = __webpack_require__(5);
+
+function LNode(gm, loc, size, vNode) {
+ //Alternative constructor 1 : LNode(LGraphManager gm, Point loc, Dimension size, Object vNode)
+ if (size == null && vNode == null) {
+ vNode = loc;
+ }
+
+ LGraphObject.call(this, vNode);
+
+ //Alternative constructor 2 : LNode(Layout layout, Object vNode)
+ if (gm.graphManager != null) gm = gm.graphManager;
+
+ this.estimatedSize = Integer.MIN_VALUE;
+ this.inclusionTreeDepth = Integer.MAX_VALUE;
+ this.vGraphObject = vNode;
+ this.edges = [];
+ this.graphManager = gm;
+
+ if (size != null && loc != null) this.rect = new RectangleD(loc.x, loc.y, size.width, size.height);else this.rect = new RectangleD();
+}
+
+LNode.prototype = Object.create(LGraphObject.prototype);
+for (var prop in LGraphObject) {
+ LNode[prop] = LGraphObject[prop];
+}
+
+LNode.prototype.getEdges = function () {
+ return this.edges;
+};
+
+LNode.prototype.getChild = function () {
+ return this.child;
+};
+
+LNode.prototype.getOwner = function () {
+ // if (this.owner != null) {
+ // if (!(this.owner == null || this.owner.getNodes().indexOf(this) > -1)) {
+ // throw "assert failed";
+ // }
+ // }
+
+ return this.owner;
+};
+
+LNode.prototype.getWidth = function () {
+ return this.rect.width;
+};
+
+LNode.prototype.setWidth = function (width) {
+ this.rect.width = width;
+};
+
+LNode.prototype.getHeight = function () {
+ return this.rect.height;
+};
+
+LNode.prototype.setHeight = function (height) {
+ this.rect.height = height;
+};
+
+LNode.prototype.getCenterX = function () {
+ return this.rect.x + this.rect.width / 2;
+};
+
+LNode.prototype.getCenterY = function () {
+ return this.rect.y + this.rect.height / 2;
+};
+
+LNode.prototype.getCenter = function () {
+ return new PointD(this.rect.x + this.rect.width / 2, this.rect.y + this.rect.height / 2);
+};
+
+LNode.prototype.getLocation = function () {
+ return new PointD(this.rect.x, this.rect.y);
+};
+
+LNode.prototype.getRect = function () {
+ return this.rect;
+};
+
+LNode.prototype.getDiagonal = function () {
+ return Math.sqrt(this.rect.width * this.rect.width + this.rect.height * this.rect.height);
+};
+
+/**
+ * This method returns half the diagonal length of this node.
+ */
+LNode.prototype.getHalfTheDiagonal = function () {
+ return Math.sqrt(this.rect.height * this.rect.height + this.rect.width * this.rect.width) / 2;
+};
+
+LNode.prototype.setRect = function (upperLeft, dimension) {
+ this.rect.x = upperLeft.x;
+ this.rect.y = upperLeft.y;
+ this.rect.width = dimension.width;
+ this.rect.height = dimension.height;
+};
+
+LNode.prototype.setCenter = function (cx, cy) {
+ this.rect.x = cx - this.rect.width / 2;
+ this.rect.y = cy - this.rect.height / 2;
+};
+
+LNode.prototype.setLocation = function (x, y) {
+ this.rect.x = x;
+ this.rect.y = y;
+};
+
+LNode.prototype.moveBy = function (dx, dy) {
+ this.rect.x += dx;
+ this.rect.y += dy;
+};
+
+LNode.prototype.getEdgeListToNode = function (to) {
+ var edgeList = [];
+ var edge;
+ var self = this;
+
+ self.edges.forEach(function (edge) {
+
+ if (edge.target == to) {
+ if (edge.source != self) throw "Incorrect edge source!";
+
+ edgeList.push(edge);
+ }
+ });
+
+ return edgeList;
+};
+
+LNode.prototype.getEdgesBetween = function (other) {
+ var edgeList = [];
+ var edge;
+
+ var self = this;
+ self.edges.forEach(function (edge) {
+
+ if (!(edge.source == self || edge.target == self)) throw "Incorrect edge source and/or target";
+
+ if (edge.target == other || edge.source == other) {
+ edgeList.push(edge);
+ }
+ });
+
+ return edgeList;
+};
+
+LNode.prototype.getNeighborsList = function () {
+ var neighbors = new Set();
+
+ var self = this;
+ self.edges.forEach(function (edge) {
+
+ if (edge.source == self) {
+ neighbors.add(edge.target);
+ } else {
+ if (edge.target != self) {
+ throw "Incorrect incidency!";
+ }
+
+ neighbors.add(edge.source);
+ }
+ });
+
+ return neighbors;
+};
+
+LNode.prototype.withChildren = function () {
+ var withNeighborsList = new Set();
+ var childNode;
+ var children;
+
+ withNeighborsList.add(this);
+
+ if (this.child != null) {
+ var nodes = this.child.getNodes();
+ for (var i = 0; i < nodes.length; i++) {
+ childNode = nodes[i];
+ children = childNode.withChildren();
+ children.forEach(function (node) {
+ withNeighborsList.add(node);
+ });
+ }
+ }
+
+ return withNeighborsList;
+};
+
+LNode.prototype.getNoOfChildren = function () {
+ var noOfChildren = 0;
+ var childNode;
+
+ if (this.child == null) {
+ noOfChildren = 1;
+ } else {
+ var nodes = this.child.getNodes();
+ for (var i = 0; i < nodes.length; i++) {
+ childNode = nodes[i];
+
+ noOfChildren += childNode.getNoOfChildren();
+ }
+ }
+
+ if (noOfChildren == 0) {
+ noOfChildren = 1;
+ }
+ return noOfChildren;
+};
+
+LNode.prototype.getEstimatedSize = function () {
+ if (this.estimatedSize == Integer.MIN_VALUE) {
+ throw "assert failed";
+ }
+ return this.estimatedSize;
+};
+
+LNode.prototype.calcEstimatedSize = function () {
+ if (this.child == null) {
+ return this.estimatedSize = (this.rect.width + this.rect.height) / 2;
+ } else {
+ this.estimatedSize = this.child.calcEstimatedSize();
+ this.rect.width = this.estimatedSize;
+ this.rect.height = this.estimatedSize;
+
+ return this.estimatedSize;
+ }
+};
+
+LNode.prototype.scatter = function () {
+ var randomCenterX;
+ var randomCenterY;
+
+ var minX = -LayoutConstants.INITIAL_WORLD_BOUNDARY;
+ var maxX = LayoutConstants.INITIAL_WORLD_BOUNDARY;
+ randomCenterX = LayoutConstants.WORLD_CENTER_X + RandomSeed.nextDouble() * (maxX - minX) + minX;
+
+ var minY = -LayoutConstants.INITIAL_WORLD_BOUNDARY;
+ var maxY = LayoutConstants.INITIAL_WORLD_BOUNDARY;
+ randomCenterY = LayoutConstants.WORLD_CENTER_Y + RandomSeed.nextDouble() * (maxY - minY) + minY;
+
+ this.rect.x = randomCenterX;
+ this.rect.y = randomCenterY;
+};
+
+LNode.prototype.updateBounds = function () {
+ if (this.getChild() == null) {
+ throw "assert failed";
+ }
+ if (this.getChild().getNodes().length != 0) {
+ // wrap the children nodes by re-arranging the boundaries
+ var childGraph = this.getChild();
+ childGraph.updateBounds(true);
+
+ this.rect.x = childGraph.getLeft();
+ this.rect.y = childGraph.getTop();
+
+ this.setWidth(childGraph.getRight() - childGraph.getLeft());
+ this.setHeight(childGraph.getBottom() - childGraph.getTop());
+
+ // Update compound bounds considering its label properties
+ if (LayoutConstants.NODE_DIMENSIONS_INCLUDE_LABELS) {
+
+ var width = childGraph.getRight() - childGraph.getLeft();
+ var height = childGraph.getBottom() - childGraph.getTop();
+
+ if (this.labelWidth) {
+ if (this.labelPosHorizontal == "left") {
+ this.rect.x -= this.labelWidth;
+ this.setWidth(width + this.labelWidth);
+ } else if (this.labelPosHorizontal == "center" && this.labelWidth > width) {
+ this.rect.x -= (this.labelWidth - width) / 2;
+ this.setWidth(this.labelWidth);
+ } else if (this.labelPosHorizontal == "right") {
+ this.setWidth(width + this.labelWidth);
+ }
+ }
+
+ if (this.labelHeight) {
+ if (this.labelPosVertical == "top") {
+ this.rect.y -= this.labelHeight;
+ this.setHeight(height + this.labelHeight);
+ } else if (this.labelPosVertical == "center" && this.labelHeight > height) {
+ this.rect.y -= (this.labelHeight - height) / 2;
+ this.setHeight(this.labelHeight);
+ } else if (this.labelPosVertical == "bottom") {
+ this.setHeight(height + this.labelHeight);
+ }
+ }
+ }
+ }
+};
+
+LNode.prototype.getInclusionTreeDepth = function () {
+ if (this.inclusionTreeDepth == Integer.MAX_VALUE) {
+ throw "assert failed";
+ }
+ return this.inclusionTreeDepth;
+};
+
+LNode.prototype.transform = function (trans) {
+ var left = this.rect.x;
+
+ if (left > LayoutConstants.WORLD_BOUNDARY) {
+ left = LayoutConstants.WORLD_BOUNDARY;
+ } else if (left < -LayoutConstants.WORLD_BOUNDARY) {
+ left = -LayoutConstants.WORLD_BOUNDARY;
+ }
+
+ var top = this.rect.y;
+
+ if (top > LayoutConstants.WORLD_BOUNDARY) {
+ top = LayoutConstants.WORLD_BOUNDARY;
+ } else if (top < -LayoutConstants.WORLD_BOUNDARY) {
+ top = -LayoutConstants.WORLD_BOUNDARY;
+ }
+
+ var leftTop = new PointD(left, top);
+ var vLeftTop = trans.inverseTransformPoint(leftTop);
+
+ this.setLocation(vLeftTop.x, vLeftTop.y);
+};
+
+LNode.prototype.getLeft = function () {
+ return this.rect.x;
+};
+
+LNode.prototype.getRight = function () {
+ return this.rect.x + this.rect.width;
+};
+
+LNode.prototype.getTop = function () {
+ return this.rect.y;
+};
+
+LNode.prototype.getBottom = function () {
+ return this.rect.y + this.rect.height;
+};
+
+LNode.prototype.getParent = function () {
+ if (this.owner == null) {
+ return null;
+ }
+
+ return this.owner.getParent();
+};
+
+module.exports = LNode;
+
+/***/ }),
+/* 4 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+var LayoutConstants = __webpack_require__(0);
+
+function FDLayoutConstants() {}
+
+//FDLayoutConstants inherits static props in LayoutConstants
+for (var prop in LayoutConstants) {
+ FDLayoutConstants[prop] = LayoutConstants[prop];
+}
+
+FDLayoutConstants.MAX_ITERATIONS = 2500;
+
+FDLayoutConstants.DEFAULT_EDGE_LENGTH = 50;
+FDLayoutConstants.DEFAULT_SPRING_STRENGTH = 0.45;
+FDLayoutConstants.DEFAULT_REPULSION_STRENGTH = 4500.0;
+FDLayoutConstants.DEFAULT_GRAVITY_STRENGTH = 0.4;
+FDLayoutConstants.DEFAULT_COMPOUND_GRAVITY_STRENGTH = 1.0;
+FDLayoutConstants.DEFAULT_GRAVITY_RANGE_FACTOR = 3.8;
+FDLayoutConstants.DEFAULT_COMPOUND_GRAVITY_RANGE_FACTOR = 1.5;
+FDLayoutConstants.DEFAULT_USE_SMART_IDEAL_EDGE_LENGTH_CALCULATION = true;
+FDLayoutConstants.DEFAULT_USE_SMART_REPULSION_RANGE_CALCULATION = true;
+FDLayoutConstants.DEFAULT_COOLING_FACTOR_INCREMENTAL = 0.3;
+FDLayoutConstants.COOLING_ADAPTATION_FACTOR = 0.33;
+FDLayoutConstants.ADAPTATION_LOWER_NODE_LIMIT = 1000;
+FDLayoutConstants.ADAPTATION_UPPER_NODE_LIMIT = 5000;
+FDLayoutConstants.MAX_NODE_DISPLACEMENT_INCREMENTAL = 100.0;
+FDLayoutConstants.MAX_NODE_DISPLACEMENT = FDLayoutConstants.MAX_NODE_DISPLACEMENT_INCREMENTAL * 3;
+FDLayoutConstants.MIN_REPULSION_DIST = FDLayoutConstants.DEFAULT_EDGE_LENGTH / 10.0;
+FDLayoutConstants.CONVERGENCE_CHECK_PERIOD = 100;
+FDLayoutConstants.PER_LEVEL_IDEAL_EDGE_LENGTH_FACTOR = 0.1;
+FDLayoutConstants.MIN_EDGE_LENGTH = 1;
+FDLayoutConstants.GRID_CALCULATION_CHECK_PERIOD = 10;
+
+module.exports = FDLayoutConstants;
+
+/***/ }),
+/* 5 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+function PointD(x, y) {
+ if (x == null && y == null) {
+ this.x = 0;
+ this.y = 0;
+ } else {
+ this.x = x;
+ this.y = y;
+ }
+}
+
+PointD.prototype.getX = function () {
+ return this.x;
+};
+
+PointD.prototype.getY = function () {
+ return this.y;
+};
+
+PointD.prototype.setX = function (x) {
+ this.x = x;
+};
+
+PointD.prototype.setY = function (y) {
+ this.y = y;
+};
+
+PointD.prototype.getDifference = function (pt) {
+ return new DimensionD(this.x - pt.x, this.y - pt.y);
+};
+
+PointD.prototype.getCopy = function () {
+ return new PointD(this.x, this.y);
+};
+
+PointD.prototype.translate = function (dim) {
+ this.x += dim.width;
+ this.y += dim.height;
+ return this;
+};
+
+module.exports = PointD;
+
+/***/ }),
+/* 6 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+var LGraphObject = __webpack_require__(2);
+var Integer = __webpack_require__(10);
+var LayoutConstants = __webpack_require__(0);
+var LGraphManager = __webpack_require__(7);
+var LNode = __webpack_require__(3);
+var LEdge = __webpack_require__(1);
+var RectangleD = __webpack_require__(13);
+var Point = __webpack_require__(12);
+var LinkedList = __webpack_require__(11);
+
+function LGraph(parent, obj2, vGraph) {
+ LGraphObject.call(this, vGraph);
+ this.estimatedSize = Integer.MIN_VALUE;
+ this.margin = LayoutConstants.DEFAULT_GRAPH_MARGIN;
+ this.edges = [];
+ this.nodes = [];
+ this.isConnected = false;
+ this.parent = parent;
+
+ if (obj2 != null && obj2 instanceof LGraphManager) {
+ this.graphManager = obj2;
+ } else if (obj2 != null && obj2 instanceof Layout) {
+ this.graphManager = obj2.graphManager;
+ }
+}
+
+LGraph.prototype = Object.create(LGraphObject.prototype);
+for (var prop in LGraphObject) {
+ LGraph[prop] = LGraphObject[prop];
+}
+
+LGraph.prototype.getNodes = function () {
+ return this.nodes;
+};
+
+LGraph.prototype.getEdges = function () {
+ return this.edges;
+};
+
+LGraph.prototype.getGraphManager = function () {
+ return this.graphManager;
+};
+
+LGraph.prototype.getParent = function () {
+ return this.parent;
+};
+
+LGraph.prototype.getLeft = function () {
+ return this.left;
+};
+
+LGraph.prototype.getRight = function () {
+ return this.right;
+};
+
+LGraph.prototype.getTop = function () {
+ return this.top;
+};
+
+LGraph.prototype.getBottom = function () {
+ return this.bottom;
+};
+
+LGraph.prototype.isConnected = function () {
+ return this.isConnected;
+};
+
+LGraph.prototype.add = function (obj1, sourceNode, targetNode) {
+ if (sourceNode == null && targetNode == null) {
+ var newNode = obj1;
+ if (this.graphManager == null) {
+ throw "Graph has no graph mgr!";
+ }
+ if (this.getNodes().indexOf(newNode) > -1) {
+ throw "Node already in graph!";
+ }
+ newNode.owner = this;
+ this.getNodes().push(newNode);
+
+ return newNode;
+ } else {
+ var newEdge = obj1;
+ if (!(this.getNodes().indexOf(sourceNode) > -1 && this.getNodes().indexOf(targetNode) > -1)) {
+ throw "Source or target not in graph!";
+ }
+
+ if (!(sourceNode.owner == targetNode.owner && sourceNode.owner == this)) {
+ throw "Both owners must be this graph!";
+ }
+
+ if (sourceNode.owner != targetNode.owner) {
+ return null;
+ }
+
+ // set source and target
+ newEdge.source = sourceNode;
+ newEdge.target = targetNode;
+
+ // set as intra-graph edge
+ newEdge.isInterGraph = false;
+
+ // add to graph edge list
+ this.getEdges().push(newEdge);
+
+ // add to incidency lists
+ sourceNode.edges.push(newEdge);
+
+ if (targetNode != sourceNode) {
+ targetNode.edges.push(newEdge);
+ }
+
+ return newEdge;
+ }
+};
+
+LGraph.prototype.remove = function (obj) {
+ var node = obj;
+ if (obj instanceof LNode) {
+ if (node == null) {
+ throw "Node is null!";
+ }
+ if (!(node.owner != null && node.owner == this)) {
+ throw "Owner graph is invalid!";
+ }
+ if (this.graphManager == null) {
+ throw "Owner graph manager is invalid!";
+ }
+ // remove incident edges first (make a copy to do it safely)
+ var edgesToBeRemoved = node.edges.slice();
+ var edge;
+ var s = edgesToBeRemoved.length;
+ for (var i = 0; i < s; i++) {
+ edge = edgesToBeRemoved[i];
+
+ if (edge.isInterGraph) {
+ this.graphManager.remove(edge);
+ } else {
+ edge.source.owner.remove(edge);
+ }
+ }
+
+ // now the node itself
+ var index = this.nodes.indexOf(node);
+ if (index == -1) {
+ throw "Node not in owner node list!";
+ }
+
+ this.nodes.splice(index, 1);
+ } else if (obj instanceof LEdge) {
+ var edge = obj;
+ if (edge == null) {
+ throw "Edge is null!";
+ }
+ if (!(edge.source != null && edge.target != null)) {
+ throw "Source and/or target is null!";
+ }
+ if (!(edge.source.owner != null && edge.target.owner != null && edge.source.owner == this && edge.target.owner == this)) {
+ throw "Source and/or target owner is invalid!";
+ }
+
+ var sourceIndex = edge.source.edges.indexOf(edge);
+ var targetIndex = edge.target.edges.indexOf(edge);
+ if (!(sourceIndex > -1 && targetIndex > -1)) {
+ throw "Source and/or target doesn't know this edge!";
+ }
+
+ edge.source.edges.splice(sourceIndex, 1);
+
+ if (edge.target != edge.source) {
+ edge.target.edges.splice(targetIndex, 1);
+ }
+
+ var index = edge.source.owner.getEdges().indexOf(edge);
+ if (index == -1) {
+ throw "Not in owner's edge list!";
+ }
+
+ edge.source.owner.getEdges().splice(index, 1);
+ }
+};
+
+LGraph.prototype.updateLeftTop = function () {
+ var top = Integer.MAX_VALUE;
+ var left = Integer.MAX_VALUE;
+ var nodeTop;
+ var nodeLeft;
+ var margin;
+
+ var nodes = this.getNodes();
+ var s = nodes.length;
+
+ for (var i = 0; i < s; i++) {
+ var lNode = nodes[i];
+ nodeTop = lNode.getTop();
+ nodeLeft = lNode.getLeft();
+
+ if (top > nodeTop) {
+ top = nodeTop;
+ }
+
+ if (left > nodeLeft) {
+ left = nodeLeft;
+ }
+ }
+
+ // Do we have any nodes in this graph?
+ if (top == Integer.MAX_VALUE) {
+ return null;
+ }
+
+ if (nodes[0].getParent().paddingLeft != undefined) {
+ margin = nodes[0].getParent().paddingLeft;
+ } else {
+ margin = this.margin;
+ }
+
+ this.left = left - margin;
+ this.top = top - margin;
+
+ // Apply the margins and return the result
+ return new Point(this.left, this.top);
+};
+
+LGraph.prototype.updateBounds = function (recursive) {
+ // calculate bounds
+ var left = Integer.MAX_VALUE;
+ var right = -Integer.MAX_VALUE;
+ var top = Integer.MAX_VALUE;
+ var bottom = -Integer.MAX_VALUE;
+ var nodeLeft;
+ var nodeRight;
+ var nodeTop;
+ var nodeBottom;
+ var margin;
+
+ var nodes = this.nodes;
+ var s = nodes.length;
+ for (var i = 0; i < s; i++) {
+ var lNode = nodes[i];
+
+ if (recursive && lNode.child != null) {
+ lNode.updateBounds();
+ }
+ nodeLeft = lNode.getLeft();
+ nodeRight = lNode.getRight();
+ nodeTop = lNode.getTop();
+ nodeBottom = lNode.getBottom();
+
+ if (left > nodeLeft) {
+ left = nodeLeft;
+ }
+
+ if (right < nodeRight) {
+ right = nodeRight;
+ }
+
+ if (top > nodeTop) {
+ top = nodeTop;
+ }
+
+ if (bottom < nodeBottom) {
+ bottom = nodeBottom;
+ }
+ }
+
+ var boundingRect = new RectangleD(left, top, right - left, bottom - top);
+ if (left == Integer.MAX_VALUE) {
+ this.left = this.parent.getLeft();
+ this.right = this.parent.getRight();
+ this.top = this.parent.getTop();
+ this.bottom = this.parent.getBottom();
+ }
+
+ if (nodes[0].getParent().paddingLeft != undefined) {
+ margin = nodes[0].getParent().paddingLeft;
+ } else {
+ margin = this.margin;
+ }
+
+ this.left = boundingRect.x - margin;
+ this.right = boundingRect.x + boundingRect.width + margin;
+ this.top = boundingRect.y - margin;
+ this.bottom = boundingRect.y + boundingRect.height + margin;
+};
+
+LGraph.calculateBounds = function (nodes) {
+ var left = Integer.MAX_VALUE;
+ var right = -Integer.MAX_VALUE;
+ var top = Integer.MAX_VALUE;
+ var bottom = -Integer.MAX_VALUE;
+ var nodeLeft;
+ var nodeRight;
+ var nodeTop;
+ var nodeBottom;
+
+ var s = nodes.length;
+
+ for (var i = 0; i < s; i++) {
+ var lNode = nodes[i];
+ nodeLeft = lNode.getLeft();
+ nodeRight = lNode.getRight();
+ nodeTop = lNode.getTop();
+ nodeBottom = lNode.getBottom();
+
+ if (left > nodeLeft) {
+ left = nodeLeft;
+ }
+
+ if (right < nodeRight) {
+ right = nodeRight;
+ }
+
+ if (top > nodeTop) {
+ top = nodeTop;
+ }
+
+ if (bottom < nodeBottom) {
+ bottom = nodeBottom;
+ }
+ }
+
+ var boundingRect = new RectangleD(left, top, right - left, bottom - top);
+
+ return boundingRect;
+};
+
+LGraph.prototype.getInclusionTreeDepth = function () {
+ if (this == this.graphManager.getRoot()) {
+ return 1;
+ } else {
+ return this.parent.getInclusionTreeDepth();
+ }
+};
+
+LGraph.prototype.getEstimatedSize = function () {
+ if (this.estimatedSize == Integer.MIN_VALUE) {
+ throw "assert failed";
+ }
+ return this.estimatedSize;
+};
+
+LGraph.prototype.calcEstimatedSize = function () {
+ var size = 0;
+ var nodes = this.nodes;
+ var s = nodes.length;
+
+ for (var i = 0; i < s; i++) {
+ var lNode = nodes[i];
+ size += lNode.calcEstimatedSize();
+ }
+
+ if (size == 0) {
+ this.estimatedSize = LayoutConstants.EMPTY_COMPOUND_NODE_SIZE;
+ } else {
+ this.estimatedSize = size / Math.sqrt(this.nodes.length);
+ }
+
+ return this.estimatedSize;
+};
+
+LGraph.prototype.updateConnected = function () {
+ var self = this;
+ if (this.nodes.length == 0) {
+ this.isConnected = true;
+ return;
+ }
+
+ var queue = new LinkedList();
+ var visited = new Set();
+ var currentNode = this.nodes[0];
+ var neighborEdges;
+ var currentNeighbor;
+ var childrenOfNode = currentNode.withChildren();
+ childrenOfNode.forEach(function (node) {
+ queue.push(node);
+ visited.add(node);
+ });
+
+ while (queue.length !== 0) {
+ currentNode = queue.shift();
+
+ // Traverse all neighbors of this node
+ neighborEdges = currentNode.getEdges();
+ var size = neighborEdges.length;
+ for (var i = 0; i < size; i++) {
+ var neighborEdge = neighborEdges[i];
+ currentNeighbor = neighborEdge.getOtherEndInGraph(currentNode, this);
+
+ // Add unvisited neighbors to the list to visit
+ if (currentNeighbor != null && !visited.has(currentNeighbor)) {
+ var childrenOfNeighbor = currentNeighbor.withChildren();
+
+ childrenOfNeighbor.forEach(function (node) {
+ queue.push(node);
+ visited.add(node);
+ });
+ }
+ }
+ }
+
+ this.isConnected = false;
+
+ if (visited.size >= this.nodes.length) {
+ var noOfVisitedInThisGraph = 0;
+
+ visited.forEach(function (visitedNode) {
+ if (visitedNode.owner == self) {
+ noOfVisitedInThisGraph++;
+ }
+ });
+
+ if (noOfVisitedInThisGraph == this.nodes.length) {
+ this.isConnected = true;
+ }
+ }
+};
+
+module.exports = LGraph;
+
+/***/ }),
+/* 7 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+var LGraph;
+var LEdge = __webpack_require__(1);
+
+function LGraphManager(layout) {
+ LGraph = __webpack_require__(6); // It may be better to initilize this out of this function but it gives an error (Right-hand side of 'instanceof' is not callable) now.
+ this.layout = layout;
+
+ this.graphs = [];
+ this.edges = [];
+}
+
+LGraphManager.prototype.addRoot = function () {
+ var ngraph = this.layout.newGraph();
+ var nnode = this.layout.newNode(null);
+ var root = this.add(ngraph, nnode);
+ this.setRootGraph(root);
+ return this.rootGraph;
+};
+
+LGraphManager.prototype.add = function (newGraph, parentNode, newEdge, sourceNode, targetNode) {
+ //there are just 2 parameters are passed then it adds an LGraph else it adds an LEdge
+ if (newEdge == null && sourceNode == null && targetNode == null) {
+ if (newGraph == null) {
+ throw "Graph is null!";
+ }
+ if (parentNode == null) {
+ throw "Parent node is null!";
+ }
+ if (this.graphs.indexOf(newGraph) > -1) {
+ throw "Graph already in this graph mgr!";
+ }
+
+ this.graphs.push(newGraph);
+
+ if (newGraph.parent != null) {
+ throw "Already has a parent!";
+ }
+ if (parentNode.child != null) {
+ throw "Already has a child!";
+ }
+
+ newGraph.parent = parentNode;
+ parentNode.child = newGraph;
+
+ return newGraph;
+ } else {
+ //change the order of the parameters
+ targetNode = newEdge;
+ sourceNode = parentNode;
+ newEdge = newGraph;
+ var sourceGraph = sourceNode.getOwner();
+ var targetGraph = targetNode.getOwner();
+
+ if (!(sourceGraph != null && sourceGraph.getGraphManager() == this)) {
+ throw "Source not in this graph mgr!";
+ }
+ if (!(targetGraph != null && targetGraph.getGraphManager() == this)) {
+ throw "Target not in this graph mgr!";
+ }
+
+ if (sourceGraph == targetGraph) {
+ newEdge.isInterGraph = false;
+ return sourceGraph.add(newEdge, sourceNode, targetNode);
+ } else {
+ newEdge.isInterGraph = true;
+
+ // set source and target
+ newEdge.source = sourceNode;
+ newEdge.target = targetNode;
+
+ // add edge to inter-graph edge list
+ if (this.edges.indexOf(newEdge) > -1) {
+ throw "Edge already in inter-graph edge list!";
+ }
+
+ this.edges.push(newEdge);
+
+ // add edge to source and target incidency lists
+ if (!(newEdge.source != null && newEdge.target != null)) {
+ throw "Edge source and/or target is null!";
+ }
+
+ if (!(newEdge.source.edges.indexOf(newEdge) == -1 && newEdge.target.edges.indexOf(newEdge) == -1)) {
+ throw "Edge already in source and/or target incidency list!";
+ }
+
+ newEdge.source.edges.push(newEdge);
+ newEdge.target.edges.push(newEdge);
+
+ return newEdge;
+ }
+ }
+};
+
+LGraphManager.prototype.remove = function (lObj) {
+ if (lObj instanceof LGraph) {
+ var graph = lObj;
+ if (graph.getGraphManager() != this) {
+ throw "Graph not in this graph mgr";
+ }
+ if (!(graph == this.rootGraph || graph.parent != null && graph.parent.graphManager == this)) {
+ throw "Invalid parent node!";
+ }
+
+ // first the edges (make a copy to do it safely)
+ var edgesToBeRemoved = [];
+
+ edgesToBeRemoved = edgesToBeRemoved.concat(graph.getEdges());
+
+ var edge;
+ var s = edgesToBeRemoved.length;
+ for (var i = 0; i < s; i++) {
+ edge = edgesToBeRemoved[i];
+ graph.remove(edge);
+ }
+
+ // then the nodes (make a copy to do it safely)
+ var nodesToBeRemoved = [];
+
+ nodesToBeRemoved = nodesToBeRemoved.concat(graph.getNodes());
+
+ var node;
+ s = nodesToBeRemoved.length;
+ for (var i = 0; i < s; i++) {
+ node = nodesToBeRemoved[i];
+ graph.remove(node);
+ }
+
+ // check if graph is the root
+ if (graph == this.rootGraph) {
+ this.setRootGraph(null);
+ }
+
+ // now remove the graph itself
+ var index = this.graphs.indexOf(graph);
+ this.graphs.splice(index, 1);
+
+ // also reset the parent of the graph
+ graph.parent = null;
+ } else if (lObj instanceof LEdge) {
+ edge = lObj;
+ if (edge == null) {
+ throw "Edge is null!";
+ }
+ if (!edge.isInterGraph) {
+ throw "Not an inter-graph edge!";
+ }
+ if (!(edge.source != null && edge.target != null)) {
+ throw "Source and/or target is null!";
+ }
+
+ // remove edge from source and target nodes' incidency lists
+
+ if (!(edge.source.edges.indexOf(edge) != -1 && edge.target.edges.indexOf(edge) != -1)) {
+ throw "Source and/or target doesn't know this edge!";
+ }
+
+ var index = edge.source.edges.indexOf(edge);
+ edge.source.edges.splice(index, 1);
+ index = edge.target.edges.indexOf(edge);
+ edge.target.edges.splice(index, 1);
+
+ // remove edge from owner graph manager's inter-graph edge list
+
+ if (!(edge.source.owner != null && edge.source.owner.getGraphManager() != null)) {
+ throw "Edge owner graph or owner graph manager is null!";
+ }
+ if (edge.source.owner.getGraphManager().edges.indexOf(edge) == -1) {
+ throw "Not in owner graph manager's edge list!";
+ }
+
+ var index = edge.source.owner.getGraphManager().edges.indexOf(edge);
+ edge.source.owner.getGraphManager().edges.splice(index, 1);
+ }
+};
+
+LGraphManager.prototype.updateBounds = function () {
+ this.rootGraph.updateBounds(true);
+};
+
+LGraphManager.prototype.getGraphs = function () {
+ return this.graphs;
+};
+
+LGraphManager.prototype.getAllNodes = function () {
+ if (this.allNodes == null) {
+ var nodeList = [];
+ var graphs = this.getGraphs();
+ var s = graphs.length;
+ for (var i = 0; i < s; i++) {
+ nodeList = nodeList.concat(graphs[i].getNodes());
+ }
+ this.allNodes = nodeList;
+ }
+ return this.allNodes;
+};
+
+LGraphManager.prototype.resetAllNodes = function () {
+ this.allNodes = null;
+};
+
+LGraphManager.prototype.resetAllEdges = function () {
+ this.allEdges = null;
+};
+
+LGraphManager.prototype.resetAllNodesToApplyGravitation = function () {
+ this.allNodesToApplyGravitation = null;
+};
+
+LGraphManager.prototype.getAllEdges = function () {
+ if (this.allEdges == null) {
+ var edgeList = [];
+ var graphs = this.getGraphs();
+ var s = graphs.length;
+ for (var i = 0; i < graphs.length; i++) {
+ edgeList = edgeList.concat(graphs[i].getEdges());
+ }
+
+ edgeList = edgeList.concat(this.edges);
+
+ this.allEdges = edgeList;
+ }
+ return this.allEdges;
+};
+
+LGraphManager.prototype.getAllNodesToApplyGravitation = function () {
+ return this.allNodesToApplyGravitation;
+};
+
+LGraphManager.prototype.setAllNodesToApplyGravitation = function (nodeList) {
+ if (this.allNodesToApplyGravitation != null) {
+ throw "assert failed";
+ }
+
+ this.allNodesToApplyGravitation = nodeList;
+};
+
+LGraphManager.prototype.getRoot = function () {
+ return this.rootGraph;
+};
+
+LGraphManager.prototype.setRootGraph = function (graph) {
+ if (graph.getGraphManager() != this) {
+ throw "Root not in this graph mgr!";
+ }
+
+ this.rootGraph = graph;
+ // root graph must have a root node associated with it for convenience
+ if (graph.parent == null) {
+ graph.parent = this.layout.newNode("Root node");
+ }
+};
+
+LGraphManager.prototype.getLayout = function () {
+ return this.layout;
+};
+
+LGraphManager.prototype.isOneAncestorOfOther = function (firstNode, secondNode) {
+ if (!(firstNode != null && secondNode != null)) {
+ throw "assert failed";
+ }
+
+ if (firstNode == secondNode) {
+ return true;
+ }
+ // Is second node an ancestor of the first one?
+ var ownerGraph = firstNode.getOwner();
+ var parentNode;
+
+ do {
+ parentNode = ownerGraph.getParent();
+
+ if (parentNode == null) {
+ break;
+ }
+
+ if (parentNode == secondNode) {
+ return true;
+ }
+
+ ownerGraph = parentNode.getOwner();
+ if (ownerGraph == null) {
+ break;
+ }
+ } while (true);
+ // Is first node an ancestor of the second one?
+ ownerGraph = secondNode.getOwner();
+
+ do {
+ parentNode = ownerGraph.getParent();
+
+ if (parentNode == null) {
+ break;
+ }
+
+ if (parentNode == firstNode) {
+ return true;
+ }
+
+ ownerGraph = parentNode.getOwner();
+ if (ownerGraph == null) {
+ break;
+ }
+ } while (true);
+
+ return false;
+};
+
+LGraphManager.prototype.calcLowestCommonAncestors = function () {
+ var edge;
+ var sourceNode;
+ var targetNode;
+ var sourceAncestorGraph;
+ var targetAncestorGraph;
+
+ var edges = this.getAllEdges();
+ var s = edges.length;
+ for (var i = 0; i < s; i++) {
+ edge = edges[i];
+
+ sourceNode = edge.source;
+ targetNode = edge.target;
+ edge.lca = null;
+ edge.sourceInLca = sourceNode;
+ edge.targetInLca = targetNode;
+
+ if (sourceNode == targetNode) {
+ edge.lca = sourceNode.getOwner();
+ continue;
+ }
+
+ sourceAncestorGraph = sourceNode.getOwner();
+
+ while (edge.lca == null) {
+ edge.targetInLca = targetNode;
+ targetAncestorGraph = targetNode.getOwner();
+
+ while (edge.lca == null) {
+ if (targetAncestorGraph == sourceAncestorGraph) {
+ edge.lca = targetAncestorGraph;
+ break;
+ }
+
+ if (targetAncestorGraph == this.rootGraph) {
+ break;
+ }
+
+ if (edge.lca != null) {
+ throw "assert failed";
+ }
+ edge.targetInLca = targetAncestorGraph.getParent();
+ targetAncestorGraph = edge.targetInLca.getOwner();
+ }
+
+ if (sourceAncestorGraph == this.rootGraph) {
+ break;
+ }
+
+ if (edge.lca == null) {
+ edge.sourceInLca = sourceAncestorGraph.getParent();
+ sourceAncestorGraph = edge.sourceInLca.getOwner();
+ }
+ }
+
+ if (edge.lca == null) {
+ throw "assert failed";
+ }
+ }
+};
+
+LGraphManager.prototype.calcLowestCommonAncestor = function (firstNode, secondNode) {
+ if (firstNode == secondNode) {
+ return firstNode.getOwner();
+ }
+ var firstOwnerGraph = firstNode.getOwner();
+
+ do {
+ if (firstOwnerGraph == null) {
+ break;
+ }
+ var secondOwnerGraph = secondNode.getOwner();
+
+ do {
+ if (secondOwnerGraph == null) {
+ break;
+ }
+
+ if (secondOwnerGraph == firstOwnerGraph) {
+ return secondOwnerGraph;
+ }
+ secondOwnerGraph = secondOwnerGraph.getParent().getOwner();
+ } while (true);
+
+ firstOwnerGraph = firstOwnerGraph.getParent().getOwner();
+ } while (true);
+
+ return firstOwnerGraph;
+};
+
+LGraphManager.prototype.calcInclusionTreeDepths = function (graph, depth) {
+ if (graph == null && depth == null) {
+ graph = this.rootGraph;
+ depth = 1;
+ }
+ var node;
+
+ var nodes = graph.getNodes();
+ var s = nodes.length;
+ for (var i = 0; i < s; i++) {
+ node = nodes[i];
+ node.inclusionTreeDepth = depth;
+
+ if (node.child != null) {
+ this.calcInclusionTreeDepths(node.child, depth + 1);
+ }
+ }
+};
+
+LGraphManager.prototype.includesInvalidEdge = function () {
+ var edge;
+ var edgesToRemove = [];
+
+ var s = this.edges.length;
+ for (var i = 0; i < s; i++) {
+ edge = this.edges[i];
+
+ if (this.isOneAncestorOfOther(edge.source, edge.target)) {
+ edgesToRemove.push(edge);
+ }
+ }
+
+ // Remove invalid edges from graph manager
+ for (var i = 0; i < edgesToRemove.length; i++) {
+ this.remove(edgesToRemove[i]);
+ }
+
+ // Invalid edges are cleared, so return false
+ return false;
+};
+
+module.exports = LGraphManager;
+
+/***/ }),
+/* 8 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+/**
+ * This class maintains a list of static geometry related utility methods.
+ *
+ *
+ * Copyright: i-Vis Research Group, Bilkent University, 2007 - present
+ */
+
+var Point = __webpack_require__(12);
+
+function IGeometry() {}
+
+/**
+ * This method calculates *half* the amount in x and y directions of the two
+ * input rectangles needed to separate them keeping their respective
+ * positioning, and returns the result in the input array. An input
+ * separation buffer added to the amount in both directions. We assume that
+ * the two rectangles do intersect.
+ */
+IGeometry.calcSeparationAmount = function (rectA, rectB, overlapAmount, separationBuffer) {
+ if (!rectA.intersects(rectB)) {
+ throw "assert failed";
+ }
+
+ var directions = new Array(2);
+
+ this.decideDirectionsForOverlappingNodes(rectA, rectB, directions);
+
+ overlapAmount[0] = Math.min(rectA.getRight(), rectB.getRight()) - Math.max(rectA.x, rectB.x);
+ overlapAmount[1] = Math.min(rectA.getBottom(), rectB.getBottom()) - Math.max(rectA.y, rectB.y);
+
+ // update the overlapping amounts for the following cases:
+ if (rectA.getX() <= rectB.getX() && rectA.getRight() >= rectB.getRight()) {
+ /* Case x.1:
+ *
+ * rectA
+ * | |
+ * | _________ |
+ * | | | |
+ * |________|_______|______|
+ * | |
+ * | |
+ * rectB
+ */
+ overlapAmount[0] += Math.min(rectB.getX() - rectA.getX(), rectA.getRight() - rectB.getRight());
+ } else if (rectB.getX() <= rectA.getX() && rectB.getRight() >= rectA.getRight()) {
+ /* Case x.2:
+ *
+ * rectB
+ * | |
+ * | _________ |
+ * | | | |
+ * |________|_______|______|
+ * | |
+ * | |
+ * rectA
+ */
+ overlapAmount[0] += Math.min(rectA.getX() - rectB.getX(), rectB.getRight() - rectA.getRight());
+ }
+ if (rectA.getY() <= rectB.getY() && rectA.getBottom() >= rectB.getBottom()) {
+ /* Case y.1:
+ * ________ rectA
+ * |
+ * |
+ * ______|____ rectB
+ * | |
+ * | |
+ * ______|____|
+ * |
+ * |
+ * |________
+ *
+ */
+ overlapAmount[1] += Math.min(rectB.getY() - rectA.getY(), rectA.getBottom() - rectB.getBottom());
+ } else if (rectB.getY() <= rectA.getY() && rectB.getBottom() >= rectA.getBottom()) {
+ /* Case y.2:
+ * ________ rectB
+ * |
+ * |
+ * ______|____ rectA
+ * | |
+ * | |
+ * ______|____|
+ * |
+ * |
+ * |________
+ *
+ */
+ overlapAmount[1] += Math.min(rectA.getY() - rectB.getY(), rectB.getBottom() - rectA.getBottom());
+ }
+
+ // find slope of the line passes two centers
+ var slope = Math.abs((rectB.getCenterY() - rectA.getCenterY()) / (rectB.getCenterX() - rectA.getCenterX()));
+ // if centers are overlapped
+ if (rectB.getCenterY() === rectA.getCenterY() && rectB.getCenterX() === rectA.getCenterX()) {
+ // assume the slope is 1 (45 degree)
+ slope = 1.0;
+ }
+
+ var moveByY = slope * overlapAmount[0];
+ var moveByX = overlapAmount[1] / slope;
+ if (overlapAmount[0] < moveByX) {
+ moveByX = overlapAmount[0];
+ } else {
+ moveByY = overlapAmount[1];
+ }
+ // return half the amount so that if each rectangle is moved by these
+ // amounts in opposite directions, overlap will be resolved
+ overlapAmount[0] = -1 * directions[0] * (moveByX / 2 + separationBuffer);
+ overlapAmount[1] = -1 * directions[1] * (moveByY / 2 + separationBuffer);
+};
+
+/**
+ * This method decides the separation direction of overlapping nodes
+ *
+ * if directions[0] = -1, then rectA goes left
+ * if directions[0] = 1, then rectA goes right
+ * if directions[1] = -1, then rectA goes up
+ * if directions[1] = 1, then rectA goes down
+ */
+IGeometry.decideDirectionsForOverlappingNodes = function (rectA, rectB, directions) {
+ if (rectA.getCenterX() < rectB.getCenterX()) {
+ directions[0] = -1;
+ } else {
+ directions[0] = 1;
+ }
+
+ if (rectA.getCenterY() < rectB.getCenterY()) {
+ directions[1] = -1;
+ } else {
+ directions[1] = 1;
+ }
+};
+
+/**
+ * This method calculates the intersection (clipping) points of the two
+ * input rectangles with line segment defined by the centers of these two
+ * rectangles. The clipping points are saved in the input double array and
+ * whether or not the two rectangles overlap is returned.
+ */
+IGeometry.getIntersection2 = function (rectA, rectB, result) {
+ //result[0-1] will contain clipPoint of rectA, result[2-3] will contain clipPoint of rectB
+ var p1x = rectA.getCenterX();
+ var p1y = rectA.getCenterY();
+ var p2x = rectB.getCenterX();
+ var p2y = rectB.getCenterY();
+
+ //if two rectangles intersect, then clipping points are centers
+ if (rectA.intersects(rectB)) {
+ result[0] = p1x;
+ result[1] = p1y;
+ result[2] = p2x;
+ result[3] = p2y;
+ return true;
+ }
+ //variables for rectA
+ var topLeftAx = rectA.getX();
+ var topLeftAy = rectA.getY();
+ var topRightAx = rectA.getRight();
+ var bottomLeftAx = rectA.getX();
+ var bottomLeftAy = rectA.getBottom();
+ var bottomRightAx = rectA.getRight();
+ var halfWidthA = rectA.getWidthHalf();
+ var halfHeightA = rectA.getHeightHalf();
+ //variables for rectB
+ var topLeftBx = rectB.getX();
+ var topLeftBy = rectB.getY();
+ var topRightBx = rectB.getRight();
+ var bottomLeftBx = rectB.getX();
+ var bottomLeftBy = rectB.getBottom();
+ var bottomRightBx = rectB.getRight();
+ var halfWidthB = rectB.getWidthHalf();
+ var halfHeightB = rectB.getHeightHalf();
+
+ //flag whether clipping points are found
+ var clipPointAFound = false;
+ var clipPointBFound = false;
+
+ // line is vertical
+ if (p1x === p2x) {
+ if (p1y > p2y) {
+ result[0] = p1x;
+ result[1] = topLeftAy;
+ result[2] = p2x;
+ result[3] = bottomLeftBy;
+ return false;
+ } else if (p1y < p2y) {
+ result[0] = p1x;
+ result[1] = bottomLeftAy;
+ result[2] = p2x;
+ result[3] = topLeftBy;
+ return false;
+ } else {
+ //not line, return null;
+ }
+ }
+ // line is horizontal
+ else if (p1y === p2y) {
+ if (p1x > p2x) {
+ result[0] = topLeftAx;
+ result[1] = p1y;
+ result[2] = topRightBx;
+ result[3] = p2y;
+ return false;
+ } else if (p1x < p2x) {
+ result[0] = topRightAx;
+ result[1] = p1y;
+ result[2] = topLeftBx;
+ result[3] = p2y;
+ return false;
+ } else {
+ //not valid line, return null;
+ }
+ } else {
+ //slopes of rectA's and rectB's diagonals
+ var slopeA = rectA.height / rectA.width;
+ var slopeB = rectB.height / rectB.width;
+
+ //slope of line between center of rectA and center of rectB
+ var slopePrime = (p2y - p1y) / (p2x - p1x);
+ var cardinalDirectionA = void 0;
+ var cardinalDirectionB = void 0;
+ var tempPointAx = void 0;
+ var tempPointAy = void 0;
+ var tempPointBx = void 0;
+ var tempPointBy = void 0;
+
+ //determine whether clipping point is the corner of nodeA
+ if (-slopeA === slopePrime) {
+ if (p1x > p2x) {
+ result[0] = bottomLeftAx;
+ result[1] = bottomLeftAy;
+ clipPointAFound = true;
+ } else {
+ result[0] = topRightAx;
+ result[1] = topLeftAy;
+ clipPointAFound = true;
+ }
+ } else if (slopeA === slopePrime) {
+ if (p1x > p2x) {
+ result[0] = topLeftAx;
+ result[1] = topLeftAy;
+ clipPointAFound = true;
+ } else {
+ result[0] = bottomRightAx;
+ result[1] = bottomLeftAy;
+ clipPointAFound = true;
+ }
+ }
+
+ //determine whether clipping point is the corner of nodeB
+ if (-slopeB === slopePrime) {
+ if (p2x > p1x) {
+ result[2] = bottomLeftBx;
+ result[3] = bottomLeftBy;
+ clipPointBFound = true;
+ } else {
+ result[2] = topRightBx;
+ result[3] = topLeftBy;
+ clipPointBFound = true;
+ }
+ } else if (slopeB === slopePrime) {
+ if (p2x > p1x) {
+ result[2] = topLeftBx;
+ result[3] = topLeftBy;
+ clipPointBFound = true;
+ } else {
+ result[2] = bottomRightBx;
+ result[3] = bottomLeftBy;
+ clipPointBFound = true;
+ }
+ }
+
+ //if both clipping points are corners
+ if (clipPointAFound && clipPointBFound) {
+ return false;
+ }
+
+ //determine Cardinal Direction of rectangles
+ if (p1x > p2x) {
+ if (p1y > p2y) {
+ cardinalDirectionA = this.getCardinalDirection(slopeA, slopePrime, 4);
+ cardinalDirectionB = this.getCardinalDirection(slopeB, slopePrime, 2);
+ } else {
+ cardinalDirectionA = this.getCardinalDirection(-slopeA, slopePrime, 3);
+ cardinalDirectionB = this.getCardinalDirection(-slopeB, slopePrime, 1);
+ }
+ } else {
+ if (p1y > p2y) {
+ cardinalDirectionA = this.getCardinalDirection(-slopeA, slopePrime, 1);
+ cardinalDirectionB = this.getCardinalDirection(-slopeB, slopePrime, 3);
+ } else {
+ cardinalDirectionA = this.getCardinalDirection(slopeA, slopePrime, 2);
+ cardinalDirectionB = this.getCardinalDirection(slopeB, slopePrime, 4);
+ }
+ }
+ //calculate clipping Point if it is not found before
+ if (!clipPointAFound) {
+ switch (cardinalDirectionA) {
+ case 1:
+ tempPointAy = topLeftAy;
+ tempPointAx = p1x + -halfHeightA / slopePrime;
+ result[0] = tempPointAx;
+ result[1] = tempPointAy;
+ break;
+ case 2:
+ tempPointAx = bottomRightAx;
+ tempPointAy = p1y + halfWidthA * slopePrime;
+ result[0] = tempPointAx;
+ result[1] = tempPointAy;
+ break;
+ case 3:
+ tempPointAy = bottomLeftAy;
+ tempPointAx = p1x + halfHeightA / slopePrime;
+ result[0] = tempPointAx;
+ result[1] = tempPointAy;
+ break;
+ case 4:
+ tempPointAx = bottomLeftAx;
+ tempPointAy = p1y + -halfWidthA * slopePrime;
+ result[0] = tempPointAx;
+ result[1] = tempPointAy;
+ break;
+ }
+ }
+ if (!clipPointBFound) {
+ switch (cardinalDirectionB) {
+ case 1:
+ tempPointBy = topLeftBy;
+ tempPointBx = p2x + -halfHeightB / slopePrime;
+ result[2] = tempPointBx;
+ result[3] = tempPointBy;
+ break;
+ case 2:
+ tempPointBx = bottomRightBx;
+ tempPointBy = p2y + halfWidthB * slopePrime;
+ result[2] = tempPointBx;
+ result[3] = tempPointBy;
+ break;
+ case 3:
+ tempPointBy = bottomLeftBy;
+ tempPointBx = p2x + halfHeightB / slopePrime;
+ result[2] = tempPointBx;
+ result[3] = tempPointBy;
+ break;
+ case 4:
+ tempPointBx = bottomLeftBx;
+ tempPointBy = p2y + -halfWidthB * slopePrime;
+ result[2] = tempPointBx;
+ result[3] = tempPointBy;
+ break;
+ }
+ }
+ }
+ return false;
+};
+
+/**
+ * This method returns in which cardinal direction does input point stays
+ * 1: North
+ * 2: East
+ * 3: South
+ * 4: West
+ */
+IGeometry.getCardinalDirection = function (slope, slopePrime, line) {
+ if (slope > slopePrime) {
+ return line;
+ } else {
+ return 1 + line % 4;
+ }
+};
+
+/**
+ * This method calculates the intersection of the two lines defined by
+ * point pairs (s1,s2) and (f1,f2).
+ */
+IGeometry.getIntersection = function (s1, s2, f1, f2) {
+ if (f2 == null) {
+ return this.getIntersection2(s1, s2, f1);
+ }
+
+ var x1 = s1.x;
+ var y1 = s1.y;
+ var x2 = s2.x;
+ var y2 = s2.y;
+ var x3 = f1.x;
+ var y3 = f1.y;
+ var x4 = f2.x;
+ var y4 = f2.y;
+ var x = void 0,
+ y = void 0; // intersection point
+ var a1 = void 0,
+ a2 = void 0,
+ b1 = void 0,
+ b2 = void 0,
+ c1 = void 0,
+ c2 = void 0; // coefficients of line eqns.
+ var denom = void 0;
+
+ a1 = y2 - y1;
+ b1 = x1 - x2;
+ c1 = x2 * y1 - x1 * y2; // { a1*x + b1*y + c1 = 0 is line 1 }
+
+ a2 = y4 - y3;
+ b2 = x3 - x4;
+ c2 = x4 * y3 - x3 * y4; // { a2*x + b2*y + c2 = 0 is line 2 }
+
+ denom = a1 * b2 - a2 * b1;
+
+ if (denom === 0) {
+ return null;
+ }
+
+ x = (b1 * c2 - b2 * c1) / denom;
+ y = (a2 * c1 - a1 * c2) / denom;
+
+ return new Point(x, y);
+};
+
+/**
+ * This method finds and returns the angle of the vector from the + x-axis
+ * in clockwise direction (compatible w/ Java coordinate system!).
+ */
+IGeometry.angleOfVector = function (Cx, Cy, Nx, Ny) {
+ var C_angle = void 0;
+
+ if (Cx !== Nx) {
+ C_angle = Math.atan((Ny - Cy) / (Nx - Cx));
+
+ if (Nx < Cx) {
+ C_angle += Math.PI;
+ } else if (Ny < Cy) {
+ C_angle += this.TWO_PI;
+ }
+ } else if (Ny < Cy) {
+ C_angle = this.ONE_AND_HALF_PI; // 270 degrees
+ } else {
+ C_angle = this.HALF_PI; // 90 degrees
+ }
+
+ return C_angle;
+};
+
+/**
+ * This method checks whether the given two line segments (one with point
+ * p1 and p2, the other with point p3 and p4) intersect at a point other
+ * than these points.
+ */
+IGeometry.doIntersect = function (p1, p2, p3, p4) {
+ var a = p1.x;
+ var b = p1.y;
+ var c = p2.x;
+ var d = p2.y;
+ var p = p3.x;
+ var q = p3.y;
+ var r = p4.x;
+ var s = p4.y;
+ var det = (c - a) * (s - q) - (r - p) * (d - b);
+
+ if (det === 0) {
+ return false;
+ } else {
+ var lambda = ((s - q) * (r - a) + (p - r) * (s - b)) / det;
+ var gamma = ((b - d) * (r - a) + (c - a) * (s - b)) / det;
+ return 0 < lambda && lambda < 1 && 0 < gamma && gamma < 1;
+ }
+};
+
+/**
+ * This method checks and calculates the intersection of
+ * a line segment and a circle.
+ */
+IGeometry.findCircleLineIntersections = function (Ex, Ey, Lx, Ly, Cx, Cy, r) {
+
+ // E is the starting point of the ray,
+ // L is the end point of the ray,
+ // C is the center of sphere you're testing against
+ // r is the radius of that sphere
+
+ // Compute:
+ // d = L - E ( Direction vector of ray, from start to end )
+ // f = E - C ( Vector from center sphere to ray start )
+
+ // Then the intersection is found by..
+ // P = E + t * d
+ // This is a parametric equation:
+ // Px = Ex + tdx
+ // Py = Ey + tdy
+
+ // get a, b, c values
+ var a = (Lx - Ex) * (Lx - Ex) + (Ly - Ey) * (Ly - Ey);
+ var b = 2 * ((Ex - Cx) * (Lx - Ex) + (Ey - Cy) * (Ly - Ey));
+ var c = (Ex - Cx) * (Ex - Cx) + (Ey - Cy) * (Ey - Cy) - r * r;
+
+ // get discriminant
+ var disc = b * b - 4 * a * c;
+ if (disc >= 0) {
+ // insert into quadratic formula
+ var t1 = (-b + Math.sqrt(b * b - 4 * a * c)) / (2 * a);
+ var t2 = (-b - Math.sqrt(b * b - 4 * a * c)) / (2 * a);
+ var intersections = null;
+ if (t1 >= 0 && t1 <= 1) {
+ // t1 is the intersection, and it's closer than t2
+ // (since t1 uses -b - discriminant)
+ // Impale, Poke
+ return [t1];
+ }
+
+ // here t1 didn't intersect so we are either started
+ // inside the sphere or completely past it
+ if (t2 >= 0 && t2 <= 1) {
+ // ExitWound
+ return [t2];
+ }
+
+ return intersections;
+ } else return null;
+};
+
+// -----------------------------------------------------------------------------
+// Section: Class Constants
+// -----------------------------------------------------------------------------
+/**
+ * Some useful pre-calculated constants
+ */
+IGeometry.HALF_PI = 0.5 * Math.PI;
+IGeometry.ONE_AND_HALF_PI = 1.5 * Math.PI;
+IGeometry.TWO_PI = 2.0 * Math.PI;
+IGeometry.THREE_PI = 3.0 * Math.PI;
+
+module.exports = IGeometry;
+
+/***/ }),
+/* 9 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+function IMath() {}
+
+/**
+ * This method returns the sign of the input value.
+ */
+IMath.sign = function (value) {
+ if (value > 0) {
+ return 1;
+ } else if (value < 0) {
+ return -1;
+ } else {
+ return 0;
+ }
+};
+
+IMath.floor = function (value) {
+ return value < 0 ? Math.ceil(value) : Math.floor(value);
+};
+
+IMath.ceil = function (value) {
+ return value < 0 ? Math.floor(value) : Math.ceil(value);
+};
+
+module.exports = IMath;
+
+/***/ }),
+/* 10 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+function Integer() {}
+
+Integer.MAX_VALUE = 2147483647;
+Integer.MIN_VALUE = -2147483648;
+
+module.exports = Integer;
+
+/***/ }),
+/* 11 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"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 nodeFrom = function nodeFrom(value) {
+ return { value: value, next: null, prev: null };
+};
+
+var add = function add(prev, node, next, list) {
+ if (prev !== null) {
+ prev.next = node;
+ } else {
+ list.head = node;
+ }
+
+ if (next !== null) {
+ next.prev = node;
+ } else {
+ list.tail = node;
+ }
+
+ node.prev = prev;
+ node.next = next;
+
+ list.length++;
+
+ return node;
+};
+
+var _remove = function _remove(node, list) {
+ var prev = node.prev,
+ next = node.next;
+
+
+ if (prev !== null) {
+ prev.next = next;
+ } else {
+ list.head = next;
+ }
+
+ if (next !== null) {
+ next.prev = prev;
+ } else {
+ list.tail = prev;
+ }
+
+ node.prev = node.next = null;
+
+ list.length--;
+
+ return node;
+};
+
+var LinkedList = function () {
+ function LinkedList(vals) {
+ var _this = this;
+
+ _classCallCheck(this, LinkedList);
+
+ this.length = 0;
+ this.head = null;
+ this.tail = null;
+
+ if (vals != null) {
+ vals.forEach(function (v) {
+ return _this.push(v);
+ });
+ }
+ }
+
+ _createClass(LinkedList, [{
+ key: "size",
+ value: function size() {
+ return this.length;
+ }
+ }, {
+ key: "insertBefore",
+ value: function insertBefore(val, otherNode) {
+ return add(otherNode.prev, nodeFrom(val), otherNode, this);
+ }
+ }, {
+ key: "insertAfter",
+ value: function insertAfter(val, otherNode) {
+ return add(otherNode, nodeFrom(val), otherNode.next, this);
+ }
+ }, {
+ key: "insertNodeBefore",
+ value: function insertNodeBefore(newNode, otherNode) {
+ return add(otherNode.prev, newNode, otherNode, this);
+ }
+ }, {
+ key: "insertNodeAfter",
+ value: function insertNodeAfter(newNode, otherNode) {
+ return add(otherNode, newNode, otherNode.next, this);
+ }
+ }, {
+ key: "push",
+ value: function push(val) {
+ return add(this.tail, nodeFrom(val), null, this);
+ }
+ }, {
+ key: "unshift",
+ value: function unshift(val) {
+ return add(null, nodeFrom(val), this.head, this);
+ }
+ }, {
+ key: "remove",
+ value: function remove(node) {
+ return _remove(node, this);
+ }
+ }, {
+ key: "pop",
+ value: function pop() {
+ return _remove(this.tail, this).value;
+ }
+ }, {
+ key: "popNode",
+ value: function popNode() {
+ return _remove(this.tail, this);
+ }
+ }, {
+ key: "shift",
+ value: function shift() {
+ return _remove(this.head, this).value;
+ }
+ }, {
+ key: "shiftNode",
+ value: function shiftNode() {
+ return _remove(this.head, this);
+ }
+ }, {
+ key: "get_object_at",
+ value: function get_object_at(index) {
+ if (index <= this.length()) {
+ var i = 1;
+ var current = this.head;
+ while (i < index) {
+ current = current.next;
+ i++;
+ }
+ return current.value;
+ }
+ }
+ }, {
+ key: "set_object_at",
+ value: function set_object_at(index, value) {
+ if (index <= this.length()) {
+ var i = 1;
+ var current = this.head;
+ while (i < index) {
+ current = current.next;
+ i++;
+ }
+ current.value = value;
+ }
+ }
+ }]);
+
+ return LinkedList;
+}();
+
+module.exports = LinkedList;
+
+/***/ }),
+/* 12 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+/*
+ *This class is the javascript implementation of the Point.java class in jdk
+ */
+function Point(x, y, p) {
+ this.x = null;
+ this.y = null;
+ if (x == null && y == null && p == null) {
+ this.x = 0;
+ this.y = 0;
+ } else if (typeof x == 'number' && typeof y == 'number' && p == null) {
+ this.x = x;
+ this.y = y;
+ } else if (x.constructor.name == 'Point' && y == null && p == null) {
+ p = x;
+ this.x = p.x;
+ this.y = p.y;
+ }
+}
+
+Point.prototype.getX = function () {
+ return this.x;
+};
+
+Point.prototype.getY = function () {
+ return this.y;
+};
+
+Point.prototype.getLocation = function () {
+ return new Point(this.x, this.y);
+};
+
+Point.prototype.setLocation = function (x, y, p) {
+ if (x.constructor.name == 'Point' && y == null && p == null) {
+ p = x;
+ this.setLocation(p.x, p.y);
+ } else if (typeof x == 'number' && typeof y == 'number' && p == null) {
+ //if both parameters are integer just move (x,y) location
+ if (parseInt(x) == x && parseInt(y) == y) {
+ this.move(x, y);
+ } else {
+ this.x = Math.floor(x + 0.5);
+ this.y = Math.floor(y + 0.5);
+ }
+ }
+};
+
+Point.prototype.move = function (x, y) {
+ this.x = x;
+ this.y = y;
+};
+
+Point.prototype.translate = function (dx, dy) {
+ this.x += dx;
+ this.y += dy;
+};
+
+Point.prototype.equals = function (obj) {
+ if (obj.constructor.name == "Point") {
+ var pt = obj;
+ return this.x == pt.x && this.y == pt.y;
+ }
+ return this == obj;
+};
+
+Point.prototype.toString = function () {
+ return new Point().constructor.name + "[x=" + this.x + ",y=" + this.y + "]";
+};
+
+module.exports = Point;
+
+/***/ }),
+/* 13 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+function RectangleD(x, y, width, height) {
+ this.x = 0;
+ this.y = 0;
+ this.width = 0;
+ this.height = 0;
+
+ if (x != null && y != null && width != null && height != null) {
+ this.x = x;
+ this.y = y;
+ this.width = width;
+ this.height = height;
+ }
+}
+
+RectangleD.prototype.getX = function () {
+ return this.x;
+};
+
+RectangleD.prototype.setX = function (x) {
+ this.x = x;
+};
+
+RectangleD.prototype.getY = function () {
+ return this.y;
+};
+
+RectangleD.prototype.setY = function (y) {
+ this.y = y;
+};
+
+RectangleD.prototype.getWidth = function () {
+ return this.width;
+};
+
+RectangleD.prototype.setWidth = function (width) {
+ this.width = width;
+};
+
+RectangleD.prototype.getHeight = function () {
+ return this.height;
+};
+
+RectangleD.prototype.setHeight = function (height) {
+ this.height = height;
+};
+
+RectangleD.prototype.getRight = function () {
+ return this.x + this.width;
+};
+
+RectangleD.prototype.getBottom = function () {
+ return this.y + this.height;
+};
+
+RectangleD.prototype.intersects = function (a) {
+ if (this.getRight() < a.x) {
+ return false;
+ }
+
+ if (this.getBottom() < a.y) {
+ return false;
+ }
+
+ if (a.getRight() < this.x) {
+ return false;
+ }
+
+ if (a.getBottom() < this.y) {
+ return false;
+ }
+
+ return true;
+};
+
+RectangleD.prototype.getCenterX = function () {
+ return this.x + this.width / 2;
+};
+
+RectangleD.prototype.getMinX = function () {
+ return this.getX();
+};
+
+RectangleD.prototype.getMaxX = function () {
+ return this.getX() + this.width;
+};
+
+RectangleD.prototype.getCenterY = function () {
+ return this.y + this.height / 2;
+};
+
+RectangleD.prototype.getMinY = function () {
+ return this.getY();
+};
+
+RectangleD.prototype.getMaxY = function () {
+ return this.getY() + this.height;
+};
+
+RectangleD.prototype.getWidthHalf = function () {
+ return this.width / 2;
+};
+
+RectangleD.prototype.getHeightHalf = function () {
+ return this.height / 2;
+};
+
+module.exports = RectangleD;
+
+/***/ }),
+/* 14 */
+/***/ (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; };
+
+function UniqueIDGeneretor() {}
+
+UniqueIDGeneretor.lastID = 0;
+
+UniqueIDGeneretor.createID = function (obj) {
+ if (UniqueIDGeneretor.isPrimitive(obj)) {
+ return obj;
+ }
+ if (obj.uniqueID != null) {
+ return obj.uniqueID;
+ }
+ obj.uniqueID = UniqueIDGeneretor.getString();
+ UniqueIDGeneretor.lastID++;
+ return obj.uniqueID;
+};
+
+UniqueIDGeneretor.getString = function (id) {
+ if (id == null) id = UniqueIDGeneretor.lastID;
+ return "Object#" + id + "";
+};
+
+UniqueIDGeneretor.isPrimitive = function (arg) {
+ var type = typeof arg === "undefined" ? "undefined" : _typeof(arg);
+ return arg == null || type != "object" && type != "function";
+};
+
+module.exports = UniqueIDGeneretor;
+
+/***/ }),
+/* 15 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
+
+var LayoutConstants = __webpack_require__(0);
+var LGraphManager = __webpack_require__(7);
+var LNode = __webpack_require__(3);
+var LEdge = __webpack_require__(1);
+var LGraph = __webpack_require__(6);
+var PointD = __webpack_require__(5);
+var Transform = __webpack_require__(17);
+var Emitter = __webpack_require__(29);
+
+function Layout(isRemoteUse) {
+ Emitter.call(this);
+
+ //Layout Quality: 0:draft, 1:default, 2:proof
+ this.layoutQuality = LayoutConstants.QUALITY;
+ //Whether layout should create bendpoints as needed or not
+ this.createBendsAsNeeded = LayoutConstants.DEFAULT_CREATE_BENDS_AS_NEEDED;
+ //Whether layout should be incremental or not
+ this.incremental = LayoutConstants.DEFAULT_INCREMENTAL;
+ //Whether we animate from before to after layout node positions
+ this.animationOnLayout = LayoutConstants.DEFAULT_ANIMATION_ON_LAYOUT;
+ //Whether we animate the layout process or not
+ this.animationDuringLayout = LayoutConstants.DEFAULT_ANIMATION_DURING_LAYOUT;
+ //Number iterations that should be done between two successive animations
+ this.animationPeriod = LayoutConstants.DEFAULT_ANIMATION_PERIOD;
+ /**
+ * Whether or not leaf nodes (non-compound nodes) are of uniform sizes. When
+ * they are, both spring and repulsion forces between two leaf nodes can be
+ * calculated without the expensive clipping point calculations, resulting
+ * in major speed-up.
+ */
+ this.uniformLeafNodeSizes = LayoutConstants.DEFAULT_UNIFORM_LEAF_NODE_SIZES;
+ /**
+ * This is used for creation of bendpoints by using dummy nodes and edges.
+ * Maps an LEdge to its dummy bendpoint path.
+ */
+ this.edgeToDummyNodes = new Map();
+ this.graphManager = new LGraphManager(this);
+ this.isLayoutFinished = false;
+ this.isSubLayout = false;
+ this.isRemoteUse = false;
+
+ if (isRemoteUse != null) {
+ this.isRemoteUse = isRemoteUse;
+ }
+}
+
+Layout.RANDOM_SEED = 1;
+
+Layout.prototype = Object.create(Emitter.prototype);
+
+Layout.prototype.getGraphManager = function () {
+ return this.graphManager;
+};
+
+Layout.prototype.getAllNodes = function () {
+ return this.graphManager.getAllNodes();
+};
+
+Layout.prototype.getAllEdges = function () {
+ return this.graphManager.getAllEdges();
+};
+
+Layout.prototype.getAllNodesToApplyGravitation = function () {
+ return this.graphManager.getAllNodesToApplyGravitation();
+};
+
+Layout.prototype.newGraphManager = function () {
+ var gm = new LGraphManager(this);
+ this.graphManager = gm;
+ return gm;
+};
+
+Layout.prototype.newGraph = function (vGraph) {
+ return new LGraph(null, this.graphManager, vGraph);
+};
+
+Layout.prototype.newNode = function (vNode) {
+ return new LNode(this.graphManager, vNode);
+};
+
+Layout.prototype.newEdge = function (vEdge) {
+ return new LEdge(null, null, vEdge);
+};
+
+Layout.prototype.checkLayoutSuccess = function () {
+ return this.graphManager.getRoot() == null || this.graphManager.getRoot().getNodes().length == 0 || this.graphManager.includesInvalidEdge();
+};
+
+Layout.prototype.runLayout = function () {
+ this.isLayoutFinished = false;
+
+ if (this.tilingPreLayout) {
+ this.tilingPreLayout();
+ }
+
+ this.initParameters();
+ var isLayoutSuccessfull;
+
+ if (this.checkLayoutSuccess()) {
+ isLayoutSuccessfull = false;
+ } else {
+ isLayoutSuccessfull = this.layout();
+ }
+
+ if (LayoutConstants.ANIMATE === 'during') {
+ // If this is a 'during' layout animation. Layout is not finished yet.
+ // We need to perform these in index.js when layout is really finished.
+ return false;
+ }
+
+ if (isLayoutSuccessfull) {
+ if (!this.isSubLayout) {
+ this.doPostLayout();
+ }
+ }
+
+ if (this.tilingPostLayout) {
+ this.tilingPostLayout();
+ }
+
+ this.isLayoutFinished = true;
+
+ return isLayoutSuccessfull;
+};
+
+/**
+ * This method performs the operations required after layout.
+ */
+Layout.prototype.doPostLayout = function () {
+ //assert !isSubLayout : "Should not be called on sub-layout!";
+ // Propagate geometric changes to v-level objects
+ if (!this.incremental) {
+ this.transform();
+ }
+ this.update();
+};
+
+/**
+ * This method updates the geometry of the target graph according to
+ * calculated layout.
+ */
+Layout.prototype.update2 = function () {
+ // update bend points
+ if (this.createBendsAsNeeded) {
+ this.createBendpointsFromDummyNodes();
+
+ // reset all edges, since the topology has changed
+ this.graphManager.resetAllEdges();
+ }
+
+ // perform edge, node and root updates if layout is not called
+ // remotely
+ if (!this.isRemoteUse) {
+ // update all edges
+ var edge;
+ var allEdges = this.graphManager.getAllEdges();
+ for (var i = 0; i < allEdges.length; i++) {
+ edge = allEdges[i];
+ // this.update(edge);
+ }
+
+ // recursively update nodes
+ var node;
+ var nodes = this.graphManager.getRoot().getNodes();
+ for (var i = 0; i < nodes.length; i++) {
+ node = nodes[i];
+ // this.update(node);
+ }
+
+ // update root graph
+ this.update(this.graphManager.getRoot());
+ }
+};
+
+Layout.prototype.update = function (obj) {
+ if (obj == null) {
+ this.update2();
+ } else if (obj instanceof LNode) {
+ var node = obj;
+ if (node.getChild() != null) {
+ // since node is compound, recursively update child nodes
+ var nodes = node.getChild().getNodes();
+ for (var i = 0; i < nodes.length; i++) {
+ update(nodes[i]);
+ }
+ }
+
+ // if the l-level node is associated with a v-level graph object,
+ // then it is assumed that the v-level node implements the
+ // interface Updatable.
+ if (node.vGraphObject != null) {
+ // cast to Updatable without any type check
+ var vNode = node.vGraphObject;
+
+ // call the update method of the interface
+ vNode.update(node);
+ }
+ } else if (obj instanceof LEdge) {
+ var edge = obj;
+ // if the l-level edge is associated with a v-level graph object,
+ // then it is assumed that the v-level edge implements the
+ // interface Updatable.
+
+ if (edge.vGraphObject != null) {
+ // cast to Updatable without any type check
+ var vEdge = edge.vGraphObject;
+
+ // call the update method of the interface
+ vEdge.update(edge);
+ }
+ } else if (obj instanceof LGraph) {
+ var graph = obj;
+ // if the l-level graph is associated with a v-level graph object,
+ // then it is assumed that the v-level object implements the
+ // interface Updatable.
+
+ if (graph.vGraphObject != null) {
+ // cast to Updatable without any type check
+ var vGraph = graph.vGraphObject;
+
+ // call the update method of the interface
+ vGraph.update(graph);
+ }
+ }
+};
+
+/**
+ * This method is used to set all layout parameters to default values
+ * determined at compile time.
+ */
+Layout.prototype.initParameters = function () {
+ if (!this.isSubLayout) {
+ this.layoutQuality = LayoutConstants.QUALITY;
+ this.animationDuringLayout = LayoutConstants.DEFAULT_ANIMATION_DURING_LAYOUT;
+ this.animationPeriod = LayoutConstants.DEFAULT_ANIMATION_PERIOD;
+ this.animationOnLayout = LayoutConstants.DEFAULT_ANIMATION_ON_LAYOUT;
+ this.incremental = LayoutConstants.DEFAULT_INCREMENTAL;
+ this.createBendsAsNeeded = LayoutConstants.DEFAULT_CREATE_BENDS_AS_NEEDED;
+ this.uniformLeafNodeSizes = LayoutConstants.DEFAULT_UNIFORM_LEAF_NODE_SIZES;
+ }
+
+ if (this.animationDuringLayout) {
+ this.animationOnLayout = false;
+ }
+};
+
+Layout.prototype.transform = function (newLeftTop) {
+ if (newLeftTop == undefined) {
+ this.transform(new PointD(0, 0));
+ } else {
+ // create a transformation object (from Eclipse to layout). When an
+ // inverse transform is applied, we get upper-left coordinate of the
+ // drawing or the root graph at given input coordinate (some margins
+ // already included in calculation of left-top).
+
+ var trans = new Transform();
+ var leftTop = this.graphManager.getRoot().updateLeftTop();
+
+ if (leftTop != null) {
+ trans.setWorldOrgX(newLeftTop.x);
+ trans.setWorldOrgY(newLeftTop.y);
+
+ trans.setDeviceOrgX(leftTop.x);
+ trans.setDeviceOrgY(leftTop.y);
+
+ var nodes = this.getAllNodes();
+ var node;
+
+ for (var i = 0; i < nodes.length; i++) {
+ node = nodes[i];
+ node.transform(trans);
+ }
+ }
+ }
+};
+
+Layout.prototype.positionNodesRandomly = function (graph) {
+
+ if (graph == undefined) {
+ //assert !this.incremental;
+ this.positionNodesRandomly(this.getGraphManager().getRoot());
+ this.getGraphManager().getRoot().updateBounds(true);
+ } else {
+ var lNode;
+ var childGraph;
+
+ var nodes = graph.getNodes();
+ for (var i = 0; i < nodes.length; i++) {
+ lNode = nodes[i];
+ childGraph = lNode.getChild();
+
+ if (childGraph == null) {
+ lNode.scatter();
+ } else if (childGraph.getNodes().length == 0) {
+ lNode.scatter();
+ } else {
+ this.positionNodesRandomly(childGraph);
+ lNode.updateBounds();
+ }
+ }
+ }
+};
+
+/**
+ * This method returns a list of trees where each tree is represented as a
+ * list of l-nodes. The method returns a list of size 0 when:
+ * - The graph is not flat or
+ * - One of the component(s) of the graph is not a tree.
+ */
+Layout.prototype.getFlatForest = function () {
+ var flatForest = [];
+ var isForest = true;
+
+ // Quick reference for all nodes in the graph manager associated with
+ // this layout. The list should not be changed.
+ var allNodes = this.graphManager.getRoot().getNodes();
+
+ // First be sure that the graph is flat
+ var isFlat = true;
+
+ for (var i = 0; i < allNodes.length; i++) {
+ if (allNodes[i].getChild() != null) {
+ isFlat = false;
+ }
+ }
+
+ // Return empty forest if the graph is not flat.
+ if (!isFlat) {
+ return flatForest;
+ }
+
+ // Run BFS for each component of the graph.
+
+ var visited = new Set();
+ var toBeVisited = [];
+ var parents = new Map();
+ var unProcessedNodes = [];
+
+ unProcessedNodes = unProcessedNodes.concat(allNodes);
+
+ // Each iteration of this loop finds a component of the graph and
+ // decides whether it is a tree or not. If it is a tree, adds it to the
+ // forest and continued with the next component.
+
+ while (unProcessedNodes.length > 0 && isForest) {
+ toBeVisited.push(unProcessedNodes[0]);
+
+ // Start the BFS. Each iteration of this loop visits a node in a
+ // BFS manner.
+ while (toBeVisited.length > 0 && isForest) {
+ //pool operation
+ var currentNode = toBeVisited[0];
+ toBeVisited.splice(0, 1);
+ visited.add(currentNode);
+
+ // Traverse all neighbors of this node
+ var neighborEdges = currentNode.getEdges();
+
+ for (var i = 0; i < neighborEdges.length; i++) {
+ var currentNeighbor = neighborEdges[i].getOtherEnd(currentNode);
+
+ // If BFS is not growing from this neighbor.
+ if (parents.get(currentNode) != currentNeighbor) {
+ // We haven't previously visited this neighbor.
+ if (!visited.has(currentNeighbor)) {
+ toBeVisited.push(currentNeighbor);
+ parents.set(currentNeighbor, currentNode);
+ }
+ // Since we have previously visited this neighbor and
+ // this neighbor is not parent of currentNode, given
+ // graph contains a component that is not tree, hence
+ // it is not a forest.
+ else {
+ isForest = false;
+ break;
+ }
+ }
+ }
+ }
+
+ // The graph contains a component that is not a tree. Empty
+ // previously found trees. The method will end.
+ if (!isForest) {
+ flatForest = [];
+ }
+ // Save currently visited nodes as a tree in our forest. Reset
+ // visited and parents lists. Continue with the next component of
+ // the graph, if any.
+ else {
+ var temp = [].concat(_toConsumableArray(visited));
+ flatForest.push(temp);
+ //flatForest = flatForest.concat(temp);
+ //unProcessedNodes.removeAll(visited);
+ for (var i = 0; i < temp.length; i++) {
+ var value = temp[i];
+ var index = unProcessedNodes.indexOf(value);
+ if (index > -1) {
+ unProcessedNodes.splice(index, 1);
+ }
+ }
+ visited = new Set();
+ parents = new Map();
+ }
+ }
+
+ return flatForest;
+};
+
+/**
+ * This method creates dummy nodes (an l-level node with minimal dimensions)
+ * for the given edge (one per bendpoint). The existing l-level structure
+ * is updated accordingly.
+ */
+Layout.prototype.createDummyNodesForBendpoints = function (edge) {
+ var dummyNodes = [];
+ var prev = edge.source;
+
+ var graph = this.graphManager.calcLowestCommonAncestor(edge.source, edge.target);
+
+ for (var i = 0; i < edge.bendpoints.length; i++) {
+ // create new dummy node
+ var dummyNode = this.newNode(null);
+ dummyNode.setRect(new Point(0, 0), new Dimension(1, 1));
+
+ graph.add(dummyNode);
+
+ // create new dummy edge between prev and dummy node
+ var dummyEdge = this.newEdge(null);
+ this.graphManager.add(dummyEdge, prev, dummyNode);
+
+ dummyNodes.add(dummyNode);
+ prev = dummyNode;
+ }
+
+ var dummyEdge = this.newEdge(null);
+ this.graphManager.add(dummyEdge, prev, edge.target);
+
+ this.edgeToDummyNodes.set(edge, dummyNodes);
+
+ // remove real edge from graph manager if it is inter-graph
+ if (edge.isInterGraph()) {
+ this.graphManager.remove(edge);
+ }
+ // else, remove the edge from the current graph
+ else {
+ graph.remove(edge);
+ }
+
+ return dummyNodes;
+};
+
+/**
+ * This method creates bendpoints for edges from the dummy nodes
+ * at l-level.
+ */
+Layout.prototype.createBendpointsFromDummyNodes = function () {
+ var edges = [];
+ edges = edges.concat(this.graphManager.getAllEdges());
+ edges = [].concat(_toConsumableArray(this.edgeToDummyNodes.keys())).concat(edges);
+
+ for (var k = 0; k < edges.length; k++) {
+ var lEdge = edges[k];
+
+ if (lEdge.bendpoints.length > 0) {
+ var path = this.edgeToDummyNodes.get(lEdge);
+
+ for (var i = 0; i < path.length; i++) {
+ var dummyNode = path[i];
+ var p = new PointD(dummyNode.getCenterX(), dummyNode.getCenterY());
+
+ // update bendpoint's location according to dummy node
+ var ebp = lEdge.bendpoints.get(i);
+ ebp.x = p.x;
+ ebp.y = p.y;
+
+ // remove the dummy node, dummy edges incident with this
+ // dummy node is also removed (within the remove method)
+ dummyNode.getOwner().remove(dummyNode);
+ }
+
+ // add the real edge to graph
+ this.graphManager.add(lEdge, lEdge.source, lEdge.target);
+ }
+ }
+};
+
+Layout.transform = function (sliderValue, defaultValue, minDiv, maxMul) {
+ if (minDiv != undefined && maxMul != undefined) {
+ var value = defaultValue;
+
+ if (sliderValue <= 50) {
+ var minValue = defaultValue / minDiv;
+ value -= (defaultValue - minValue) / 50 * (50 - sliderValue);
+ } else {
+ var maxValue = defaultValue * maxMul;
+ value += (maxValue - defaultValue) / 50 * (sliderValue - 50);
+ }
+
+ return value;
+ } else {
+ var a, b;
+
+ if (sliderValue <= 50) {
+ a = 9.0 * defaultValue / 500.0;
+ b = defaultValue / 10.0;
+ } else {
+ a = 9.0 * defaultValue / 50.0;
+ b = -8 * defaultValue;
+ }
+
+ return a * sliderValue + b;
+ }
+};
+
+/**
+ * This method finds and returns the center of the given nodes, assuming
+ * that the given nodes form a tree in themselves.
+ */
+Layout.findCenterOfTree = function (nodes) {
+ var list = [];
+ list = list.concat(nodes);
+
+ var removedNodes = [];
+ var remainingDegrees = new Map();
+ var foundCenter = false;
+ var centerNode = null;
+
+ if (list.length == 1 || list.length == 2) {
+ foundCenter = true;
+ centerNode = list[0];
+ }
+
+ for (var i = 0; i < list.length; i++) {
+ var node = list[i];
+ var degree = node.getNeighborsList().size;
+ remainingDegrees.set(node, node.getNeighborsList().size);
+
+ if (degree == 1) {
+ removedNodes.push(node);
+ }
+ }
+
+ var tempList = [];
+ tempList = tempList.concat(removedNodes);
+
+ while (!foundCenter) {
+ var tempList2 = [];
+ tempList2 = tempList2.concat(tempList);
+ tempList = [];
+
+ for (var i = 0; i < list.length; i++) {
+ var node = list[i];
+
+ var index = list.indexOf(node);
+ if (index >= 0) {
+ list.splice(index, 1);
+ }
+
+ var neighbours = node.getNeighborsList();
+
+ neighbours.forEach(function (neighbour) {
+ if (removedNodes.indexOf(neighbour) < 0) {
+ var otherDegree = remainingDegrees.get(neighbour);
+ var newDegree = otherDegree - 1;
+
+ if (newDegree == 1) {
+ tempList.push(neighbour);
+ }
+
+ remainingDegrees.set(neighbour, newDegree);
+ }
+ });
+ }
+
+ removedNodes = removedNodes.concat(tempList);
+
+ if (list.length == 1 || list.length == 2) {
+ foundCenter = true;
+ centerNode = list[0];
+ }
+ }
+
+ return centerNode;
+};
+
+/**
+ * During the coarsening process, this layout may be referenced by two graph managers
+ * this setter function grants access to change the currently being used graph manager
+ */
+Layout.prototype.setGraphManager = function (gm) {
+ this.graphManager = gm;
+};
+
+module.exports = Layout;
+
+/***/ }),
+/* 16 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+function RandomSeed() {}
+// adapted from: https://stackoverflow.com/a/19303725
+RandomSeed.seed = 1;
+RandomSeed.x = 0;
+
+RandomSeed.nextDouble = function () {
+ RandomSeed.x = Math.sin(RandomSeed.seed++) * 10000;
+ return RandomSeed.x - Math.floor(RandomSeed.x);
+};
+
+module.exports = RandomSeed;
+
+/***/ }),
+/* 17 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+var PointD = __webpack_require__(5);
+
+function Transform(x, y) {
+ this.lworldOrgX = 0.0;
+ this.lworldOrgY = 0.0;
+ this.ldeviceOrgX = 0.0;
+ this.ldeviceOrgY = 0.0;
+ this.lworldExtX = 1.0;
+ this.lworldExtY = 1.0;
+ this.ldeviceExtX = 1.0;
+ this.ldeviceExtY = 1.0;
+}
+
+Transform.prototype.getWorldOrgX = function () {
+ return this.lworldOrgX;
+};
+
+Transform.prototype.setWorldOrgX = function (wox) {
+ this.lworldOrgX = wox;
+};
+
+Transform.prototype.getWorldOrgY = function () {
+ return this.lworldOrgY;
+};
+
+Transform.prototype.setWorldOrgY = function (woy) {
+ this.lworldOrgY = woy;
+};
+
+Transform.prototype.getWorldExtX = function () {
+ return this.lworldExtX;
+};
+
+Transform.prototype.setWorldExtX = function (wex) {
+ this.lworldExtX = wex;
+};
+
+Transform.prototype.getWorldExtY = function () {
+ return this.lworldExtY;
+};
+
+Transform.prototype.setWorldExtY = function (wey) {
+ this.lworldExtY = wey;
+};
+
+/* Device related */
+
+Transform.prototype.getDeviceOrgX = function () {
+ return this.ldeviceOrgX;
+};
+
+Transform.prototype.setDeviceOrgX = function (dox) {
+ this.ldeviceOrgX = dox;
+};
+
+Transform.prototype.getDeviceOrgY = function () {
+ return this.ldeviceOrgY;
+};
+
+Transform.prototype.setDeviceOrgY = function (doy) {
+ this.ldeviceOrgY = doy;
+};
+
+Transform.prototype.getDeviceExtX = function () {
+ return this.ldeviceExtX;
+};
+
+Transform.prototype.setDeviceExtX = function (dex) {
+ this.ldeviceExtX = dex;
+};
+
+Transform.prototype.getDeviceExtY = function () {
+ return this.ldeviceExtY;
+};
+
+Transform.prototype.setDeviceExtY = function (dey) {
+ this.ldeviceExtY = dey;
+};
+
+Transform.prototype.transformX = function (x) {
+ var xDevice = 0.0;
+ var worldExtX = this.lworldExtX;
+ if (worldExtX != 0.0) {
+ xDevice = this.ldeviceOrgX + (x - this.lworldOrgX) * this.ldeviceExtX / worldExtX;
+ }
+
+ return xDevice;
+};
+
+Transform.prototype.transformY = function (y) {
+ var yDevice = 0.0;
+ var worldExtY = this.lworldExtY;
+ if (worldExtY != 0.0) {
+ yDevice = this.ldeviceOrgY + (y - this.lworldOrgY) * this.ldeviceExtY / worldExtY;
+ }
+
+ return yDevice;
+};
+
+Transform.prototype.inverseTransformX = function (x) {
+ var xWorld = 0.0;
+ var deviceExtX = this.ldeviceExtX;
+ if (deviceExtX != 0.0) {
+ xWorld = this.lworldOrgX + (x - this.ldeviceOrgX) * this.lworldExtX / deviceExtX;
+ }
+
+ return xWorld;
+};
+
+Transform.prototype.inverseTransformY = function (y) {
+ var yWorld = 0.0;
+ var deviceExtY = this.ldeviceExtY;
+ if (deviceExtY != 0.0) {
+ yWorld = this.lworldOrgY + (y - this.ldeviceOrgY) * this.lworldExtY / deviceExtY;
+ }
+ return yWorld;
+};
+
+Transform.prototype.inverseTransformPoint = function (inPoint) {
+ var outPoint = new PointD(this.inverseTransformX(inPoint.x), this.inverseTransformY(inPoint.y));
+ return outPoint;
+};
+
+module.exports = Transform;
+
+/***/ }),
+/* 18 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
+
+var Layout = __webpack_require__(15);
+var FDLayoutConstants = __webpack_require__(4);
+var LayoutConstants = __webpack_require__(0);
+var IGeometry = __webpack_require__(8);
+var IMath = __webpack_require__(9);
+
+function FDLayout() {
+ Layout.call(this);
+
+ this.useSmartIdealEdgeLengthCalculation = FDLayoutConstants.DEFAULT_USE_SMART_IDEAL_EDGE_LENGTH_CALCULATION;
+ this.gravityConstant = FDLayoutConstants.DEFAULT_GRAVITY_STRENGTH;
+ this.compoundGravityConstant = FDLayoutConstants.DEFAULT_COMPOUND_GRAVITY_STRENGTH;
+ this.gravityRangeFactor = FDLayoutConstants.DEFAULT_GRAVITY_RANGE_FACTOR;
+ this.compoundGravityRangeFactor = FDLayoutConstants.DEFAULT_COMPOUND_GRAVITY_RANGE_FACTOR;
+ this.displacementThresholdPerNode = 3.0 * FDLayoutConstants.DEFAULT_EDGE_LENGTH / 100;
+ this.coolingFactor = FDLayoutConstants.DEFAULT_COOLING_FACTOR_INCREMENTAL;
+ this.initialCoolingFactor = FDLayoutConstants.DEFAULT_COOLING_FACTOR_INCREMENTAL;
+ this.totalDisplacement = 0.0;
+ this.oldTotalDisplacement = 0.0;
+ this.maxIterations = FDLayoutConstants.MAX_ITERATIONS;
+}
+
+FDLayout.prototype = Object.create(Layout.prototype);
+
+for (var prop in Layout) {
+ FDLayout[prop] = Layout[prop];
+}
+
+FDLayout.prototype.initParameters = function () {
+ Layout.prototype.initParameters.call(this, arguments);
+
+ this.totalIterations = 0;
+ this.notAnimatedIterations = 0;
+
+ this.useFRGridVariant = FDLayoutConstants.DEFAULT_USE_SMART_REPULSION_RANGE_CALCULATION;
+
+ this.grid = [];
+};
+
+FDLayout.prototype.calcIdealEdgeLengths = function () {
+ var edge;
+ var originalIdealLength;
+ var lcaDepth;
+ var source;
+ var target;
+ var sizeOfSourceInLca;
+ var sizeOfTargetInLca;
+
+ var allEdges = this.getGraphManager().getAllEdges();
+ for (var i = 0; i < allEdges.length; i++) {
+ edge = allEdges[i];
+
+ originalIdealLength = edge.idealLength;
+
+ if (edge.isInterGraph) {
+ source = edge.getSource();
+ target = edge.getTarget();
+
+ sizeOfSourceInLca = edge.getSourceInLca().getEstimatedSize();
+ sizeOfTargetInLca = edge.getTargetInLca().getEstimatedSize();
+
+ if (this.useSmartIdealEdgeLengthCalculation) {
+ edge.idealLength += sizeOfSourceInLca + sizeOfTargetInLca - 2 * LayoutConstants.SIMPLE_NODE_SIZE;
+ }
+
+ lcaDepth = edge.getLca().getInclusionTreeDepth();
+
+ edge.idealLength += originalIdealLength * FDLayoutConstants.PER_LEVEL_IDEAL_EDGE_LENGTH_FACTOR * (source.getInclusionTreeDepth() + target.getInclusionTreeDepth() - 2 * lcaDepth);
+ }
+ }
+};
+
+FDLayout.prototype.initSpringEmbedder = function () {
+
+ var s = this.getAllNodes().length;
+ if (this.incremental) {
+ if (s > FDLayoutConstants.ADAPTATION_LOWER_NODE_LIMIT) {
+ this.coolingFactor = Math.max(this.coolingFactor * FDLayoutConstants.COOLING_ADAPTATION_FACTOR, this.coolingFactor - (s - FDLayoutConstants.ADAPTATION_LOWER_NODE_LIMIT) / (FDLayoutConstants.ADAPTATION_UPPER_NODE_LIMIT - FDLayoutConstants.ADAPTATION_LOWER_NODE_LIMIT) * this.coolingFactor * (1 - FDLayoutConstants.COOLING_ADAPTATION_FACTOR));
+ }
+ this.maxNodeDisplacement = FDLayoutConstants.MAX_NODE_DISPLACEMENT_INCREMENTAL;
+ } else {
+ if (s > FDLayoutConstants.ADAPTATION_LOWER_NODE_LIMIT) {
+ this.coolingFactor = Math.max(FDLayoutConstants.COOLING_ADAPTATION_FACTOR, 1.0 - (s - FDLayoutConstants.ADAPTATION_LOWER_NODE_LIMIT) / (FDLayoutConstants.ADAPTATION_UPPER_NODE_LIMIT - FDLayoutConstants.ADAPTATION_LOWER_NODE_LIMIT) * (1 - FDLayoutConstants.COOLING_ADAPTATION_FACTOR));
+ } else {
+ this.coolingFactor = 1.0;
+ }
+ this.initialCoolingFactor = this.coolingFactor;
+ this.maxNodeDisplacement = FDLayoutConstants.MAX_NODE_DISPLACEMENT;
+ }
+
+ this.maxIterations = Math.max(this.getAllNodes().length * 5, this.maxIterations);
+
+ // Reassign this attribute by using new constant value
+ this.displacementThresholdPerNode = 3.0 * FDLayoutConstants.DEFAULT_EDGE_LENGTH / 100;
+ this.totalDisplacementThreshold = this.displacementThresholdPerNode * this.getAllNodes().length;
+
+ this.repulsionRange = this.calcRepulsionRange();
+};
+
+FDLayout.prototype.calcSpringForces = function () {
+ var lEdges = this.getAllEdges();
+ var edge;
+
+ for (var i = 0; i < lEdges.length; i++) {
+ edge = lEdges[i];
+
+ this.calcSpringForce(edge, edge.idealLength);
+ }
+};
+
+FDLayout.prototype.calcRepulsionForces = function () {
+ var gridUpdateAllowed = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+ var forceToNodeSurroundingUpdate = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+
+ var i, j;
+ var nodeA, nodeB;
+ var lNodes = this.getAllNodes();
+ var processedNodeSet;
+
+ if (this.useFRGridVariant) {
+ if (this.totalIterations % FDLayoutConstants.GRID_CALCULATION_CHECK_PERIOD == 1 && gridUpdateAllowed) {
+ this.updateGrid();
+ }
+
+ processedNodeSet = new Set();
+
+ // calculate repulsion forces between each nodes and its surrounding
+ for (i = 0; i < lNodes.length; i++) {
+ nodeA = lNodes[i];
+ this.calculateRepulsionForceOfANode(nodeA, processedNodeSet, gridUpdateAllowed, forceToNodeSurroundingUpdate);
+ processedNodeSet.add(nodeA);
+ }
+ } else {
+ for (i = 0; i < lNodes.length; i++) {
+ nodeA = lNodes[i];
+
+ for (j = i + 1; j < lNodes.length; j++) {
+ nodeB = lNodes[j];
+
+ // If both nodes are not members of the same graph, skip.
+ if (nodeA.getOwner() != nodeB.getOwner()) {
+ continue;
+ }
+
+ this.calcRepulsionForce(nodeA, nodeB);
+ }
+ }
+ }
+};
+
+FDLayout.prototype.calcGravitationalForces = function () {
+ var node;
+ var lNodes = this.getAllNodesToApplyGravitation();
+
+ for (var i = 0; i < lNodes.length; i++) {
+ node = lNodes[i];
+ this.calcGravitationalForce(node);
+ }
+};
+
+FDLayout.prototype.moveNodes = function () {
+ var lNodes = this.getAllNodes();
+ var node;
+
+ for (var i = 0; i < lNodes.length; i++) {
+ node = lNodes[i];
+ node.move();
+ }
+};
+
+FDLayout.prototype.calcSpringForce = function (edge, idealLength) {
+ var sourceNode = edge.getSource();
+ var targetNode = edge.getTarget();
+
+ var length;
+ var springForce;
+ var springForceX;
+ var springForceY;
+
+ // Update edge length
+ if (this.uniformLeafNodeSizes && sourceNode.getChild() == null && targetNode.getChild() == null) {
+ edge.updateLengthSimple();
+ } else {
+ edge.updateLength();
+
+ if (edge.isOverlapingSourceAndTarget) {
+ return;
+ }
+ }
+
+ length = edge.getLength();
+
+ if (length == 0) return;
+
+ // Calculate spring forces
+ springForce = edge.edgeElasticity * (length - idealLength);
+
+ // Project force onto x and y axes
+ springForceX = springForce * (edge.lengthX / length);
+ springForceY = springForce * (edge.lengthY / length);
+
+ // Apply forces on the end nodes
+ sourceNode.springForceX += springForceX;
+ sourceNode.springForceY += springForceY;
+ targetNode.springForceX -= springForceX;
+ targetNode.springForceY -= springForceY;
+};
+
+FDLayout.prototype.calcRepulsionForce = function (nodeA, nodeB) {
+ var rectA = nodeA.getRect();
+ var rectB = nodeB.getRect();
+ var overlapAmount = new Array(2);
+ var clipPoints = new Array(4);
+ var distanceX;
+ var distanceY;
+ var distanceSquared;
+ var distance;
+ var repulsionForce;
+ var repulsionForceX;
+ var repulsionForceY;
+
+ if (rectA.intersects(rectB)) // two nodes overlap
+ {
+ // calculate separation amount in x and y directions
+ IGeometry.calcSeparationAmount(rectA, rectB, overlapAmount, FDLayoutConstants.DEFAULT_EDGE_LENGTH / 2.0);
+
+ repulsionForceX = 2 * overlapAmount[0];
+ repulsionForceY = 2 * overlapAmount[1];
+
+ var childrenConstant = nodeA.noOfChildren * nodeB.noOfChildren / (nodeA.noOfChildren + nodeB.noOfChildren);
+
+ // Apply forces on the two nodes
+ nodeA.repulsionForceX -= childrenConstant * repulsionForceX;
+ nodeA.repulsionForceY -= childrenConstant * repulsionForceY;
+ nodeB.repulsionForceX += childrenConstant * repulsionForceX;
+ nodeB.repulsionForceY += childrenConstant * repulsionForceY;
+ } else // no overlap
+ {
+ // calculate distance
+
+ if (this.uniformLeafNodeSizes && nodeA.getChild() == null && nodeB.getChild() == null) // simply base repulsion on distance of node centers
+ {
+ distanceX = rectB.getCenterX() - rectA.getCenterX();
+ distanceY = rectB.getCenterY() - rectA.getCenterY();
+ } else // use clipping points
+ {
+ IGeometry.getIntersection(rectA, rectB, clipPoints);
+
+ distanceX = clipPoints[2] - clipPoints[0];
+ distanceY = clipPoints[3] - clipPoints[1];
+ }
+
+ // No repulsion range. FR grid variant should take care of this.
+ if (Math.abs(distanceX) < FDLayoutConstants.MIN_REPULSION_DIST) {
+ distanceX = IMath.sign(distanceX) * FDLayoutConstants.MIN_REPULSION_DIST;
+ }
+
+ if (Math.abs(distanceY) < FDLayoutConstants.MIN_REPULSION_DIST) {
+ distanceY = IMath.sign(distanceY) * FDLayoutConstants.MIN_REPULSION_DIST;
+ }
+
+ distanceSquared = distanceX * distanceX + distanceY * distanceY;
+ distance = Math.sqrt(distanceSquared);
+
+ // Here we use half of the nodes' repulsion values for backward compatibility
+ repulsionForce = (nodeA.nodeRepulsion / 2 + nodeB.nodeRepulsion / 2) * nodeA.noOfChildren * nodeB.noOfChildren / distanceSquared;
+
+ // Project force onto x and y axes
+ repulsionForceX = repulsionForce * distanceX / distance;
+ repulsionForceY = repulsionForce * distanceY / distance;
+
+ // Apply forces on the two nodes
+ nodeA.repulsionForceX -= repulsionForceX;
+ nodeA.repulsionForceY -= repulsionForceY;
+ nodeB.repulsionForceX += repulsionForceX;
+ nodeB.repulsionForceY += repulsionForceY;
+ }
+};
+
+FDLayout.prototype.calcGravitationalForce = function (node) {
+ var ownerGraph;
+ var ownerCenterX;
+ var ownerCenterY;
+ var distanceX;
+ var distanceY;
+ var absDistanceX;
+ var absDistanceY;
+ var estimatedSize;
+ ownerGraph = node.getOwner();
+
+ ownerCenterX = (ownerGraph.getRight() + ownerGraph.getLeft()) / 2;
+ ownerCenterY = (ownerGraph.getTop() + ownerGraph.getBottom()) / 2;
+ distanceX = node.getCenterX() - ownerCenterX;
+ distanceY = node.getCenterY() - ownerCenterY;
+ absDistanceX = Math.abs(distanceX) + node.getWidth() / 2;
+ absDistanceY = Math.abs(distanceY) + node.getHeight() / 2;
+
+ if (node.getOwner() == this.graphManager.getRoot()) // in the root graph
+ {
+ estimatedSize = ownerGraph.getEstimatedSize() * this.gravityRangeFactor;
+
+ if (absDistanceX > estimatedSize || absDistanceY > estimatedSize) {
+ node.gravitationForceX = -this.gravityConstant * distanceX;
+ node.gravitationForceY = -this.gravityConstant * distanceY;
+ }
+ } else // inside a compound
+ {
+ estimatedSize = ownerGraph.getEstimatedSize() * this.compoundGravityRangeFactor;
+
+ if (absDistanceX > estimatedSize || absDistanceY > estimatedSize) {
+ node.gravitationForceX = -this.gravityConstant * distanceX * this.compoundGravityConstant;
+ node.gravitationForceY = -this.gravityConstant * distanceY * this.compoundGravityConstant;
+ }
+ }
+};
+
+FDLayout.prototype.isConverged = function () {
+ var converged;
+ var oscilating = false;
+
+ if (this.totalIterations > this.maxIterations / 3) {
+ oscilating = Math.abs(this.totalDisplacement - this.oldTotalDisplacement) < 2;
+ }
+
+ converged = this.totalDisplacement < this.totalDisplacementThreshold;
+
+ this.oldTotalDisplacement = this.totalDisplacement;
+
+ return converged || oscilating;
+};
+
+FDLayout.prototype.animate = function () {
+ if (this.animationDuringLayout && !this.isSubLayout) {
+ if (this.notAnimatedIterations == this.animationPeriod) {
+ this.update();
+ this.notAnimatedIterations = 0;
+ } else {
+ this.notAnimatedIterations++;
+ }
+ }
+};
+
+//This method calculates the number of children (weight) for all nodes
+FDLayout.prototype.calcNoOfChildrenForAllNodes = function () {
+ var node;
+ var allNodes = this.graphManager.getAllNodes();
+
+ for (var i = 0; i < allNodes.length; i++) {
+ node = allNodes[i];
+ node.noOfChildren = node.getNoOfChildren();
+ }
+};
+
+// -----------------------------------------------------------------------------
+// Section: FR-Grid Variant Repulsion Force Calculation
+// -----------------------------------------------------------------------------
+
+FDLayout.prototype.calcGrid = function (graph) {
+
+ var sizeX = 0;
+ var sizeY = 0;
+
+ sizeX = parseInt(Math.ceil((graph.getRight() - graph.getLeft()) / this.repulsionRange));
+ sizeY = parseInt(Math.ceil((graph.getBottom() - graph.getTop()) / this.repulsionRange));
+
+ var grid = new Array(sizeX);
+
+ for (var i = 0; i < sizeX; i++) {
+ grid[i] = new Array(sizeY);
+ }
+
+ for (var i = 0; i < sizeX; i++) {
+ for (var j = 0; j < sizeY; j++) {
+ grid[i][j] = new Array();
+ }
+ }
+
+ return grid;
+};
+
+FDLayout.prototype.addNodeToGrid = function (v, left, top) {
+
+ var startX = 0;
+ var finishX = 0;
+ var startY = 0;
+ var finishY = 0;
+
+ startX = parseInt(Math.floor((v.getRect().x - left) / this.repulsionRange));
+ finishX = parseInt(Math.floor((v.getRect().width + v.getRect().x - left) / this.repulsionRange));
+ startY = parseInt(Math.floor((v.getRect().y - top) / this.repulsionRange));
+ finishY = parseInt(Math.floor((v.getRect().height + v.getRect().y - top) / this.repulsionRange));
+
+ for (var i = startX; i <= finishX; i++) {
+ for (var j = startY; j <= finishY; j++) {
+ this.grid[i][j].push(v);
+ v.setGridCoordinates(startX, finishX, startY, finishY);
+ }
+ }
+};
+
+FDLayout.prototype.updateGrid = function () {
+ var i;
+ var nodeA;
+ var lNodes = this.getAllNodes();
+
+ this.grid = this.calcGrid(this.graphManager.getRoot());
+
+ // put all nodes to proper grid cells
+ for (i = 0; i < lNodes.length; i++) {
+ nodeA = lNodes[i];
+ this.addNodeToGrid(nodeA, this.graphManager.getRoot().getLeft(), this.graphManager.getRoot().getTop());
+ }
+};
+
+FDLayout.prototype.calculateRepulsionForceOfANode = function (nodeA, processedNodeSet, gridUpdateAllowed, forceToNodeSurroundingUpdate) {
+
+ if (this.totalIterations % FDLayoutConstants.GRID_CALCULATION_CHECK_PERIOD == 1 && gridUpdateAllowed || forceToNodeSurroundingUpdate) {
+ var surrounding = new Set();
+ nodeA.surrounding = new Array();
+ var nodeB;
+ var grid = this.grid;
+
+ for (var i = nodeA.startX - 1; i < nodeA.finishX + 2; i++) {
+ for (var j = nodeA.startY - 1; j < nodeA.finishY + 2; j++) {
+ if (!(i < 0 || j < 0 || i >= grid.length || j >= grid[0].length)) {
+ for (var k = 0; k < grid[i][j].length; k++) {
+ nodeB = grid[i][j][k];
+
+ // If both nodes are not members of the same graph,
+ // or both nodes are the same, skip.
+ if (nodeA.getOwner() != nodeB.getOwner() || nodeA == nodeB) {
+ continue;
+ }
+
+ // check if the repulsion force between
+ // nodeA and nodeB has already been calculated
+ if (!processedNodeSet.has(nodeB) && !surrounding.has(nodeB)) {
+ var distanceX = Math.abs(nodeA.getCenterX() - nodeB.getCenterX()) - (nodeA.getWidth() / 2 + nodeB.getWidth() / 2);
+ var distanceY = Math.abs(nodeA.getCenterY() - nodeB.getCenterY()) - (nodeA.getHeight() / 2 + nodeB.getHeight() / 2);
+
+ // if the distance between nodeA and nodeB
+ // is less then calculation range
+ if (distanceX <= this.repulsionRange && distanceY <= this.repulsionRange) {
+ //then add nodeB to surrounding of nodeA
+ surrounding.add(nodeB);
+ }
+ }
+ }
+ }
+ }
+ }
+
+ nodeA.surrounding = [].concat(_toConsumableArray(surrounding));
+ }
+ for (i = 0; i < nodeA.surrounding.length; i++) {
+ this.calcRepulsionForce(nodeA, nodeA.surrounding[i]);
+ }
+};
+
+FDLayout.prototype.calcRepulsionRange = function () {
+ return 0.0;
+};
+
+module.exports = FDLayout;
+
+/***/ }),
+/* 19 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+var LEdge = __webpack_require__(1);
+var FDLayoutConstants = __webpack_require__(4);
+
+function FDLayoutEdge(source, target, vEdge) {
+ LEdge.call(this, source, target, vEdge);
+
+ // Ideal length and elasticity value for this edge
+ this.idealLength = FDLayoutConstants.DEFAULT_EDGE_LENGTH;
+ this.edgeElasticity = FDLayoutConstants.DEFAULT_SPRING_STRENGTH;
+}
+
+FDLayoutEdge.prototype = Object.create(LEdge.prototype);
+
+for (var prop in LEdge) {
+ FDLayoutEdge[prop] = LEdge[prop];
+}
+
+module.exports = FDLayoutEdge;
+
+/***/ }),
+/* 20 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+var LNode = __webpack_require__(3);
+var FDLayoutConstants = __webpack_require__(4);
+
+function FDLayoutNode(gm, loc, size, vNode) {
+ // alternative constructor is handled inside LNode
+ LNode.call(this, gm, loc, size, vNode);
+
+ // Repulsion value of this node
+ this.nodeRepulsion = FDLayoutConstants.DEFAULT_REPULSION_STRENGTH;
+
+ //Spring, repulsion and gravitational forces acting on this node
+ this.springForceX = 0;
+ this.springForceY = 0;
+ this.repulsionForceX = 0;
+ this.repulsionForceY = 0;
+ this.gravitationForceX = 0;
+ this.gravitationForceY = 0;
+ //Amount by which this node is to be moved in this iteration
+ this.displacementX = 0;
+ this.displacementY = 0;
+
+ //Start and finish grid coordinates that this node is fallen into
+ this.startX = 0;
+ this.finishX = 0;
+ this.startY = 0;
+ this.finishY = 0;
+
+ //Geometric neighbors of this node
+ this.surrounding = [];
+}
+
+FDLayoutNode.prototype = Object.create(LNode.prototype);
+
+for (var prop in LNode) {
+ FDLayoutNode[prop] = LNode[prop];
+}
+
+FDLayoutNode.prototype.setGridCoordinates = function (_startX, _finishX, _startY, _finishY) {
+ this.startX = _startX;
+ this.finishX = _finishX;
+ this.startY = _startY;
+ this.finishY = _finishY;
+};
+
+module.exports = FDLayoutNode;
+
+/***/ }),
+/* 21 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+function DimensionD(width, height) {
+ this.width = 0;
+ this.height = 0;
+ if (width !== null && height !== null) {
+ this.height = height;
+ this.width = width;
+ }
+}
+
+DimensionD.prototype.getWidth = function () {
+ return this.width;
+};
+
+DimensionD.prototype.setWidth = function (width) {
+ this.width = width;
+};
+
+DimensionD.prototype.getHeight = function () {
+ return this.height;
+};
+
+DimensionD.prototype.setHeight = function (height) {
+ this.height = height;
+};
+
+module.exports = DimensionD;
+
+/***/ }),
+/* 22 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+var UniqueIDGeneretor = __webpack_require__(14);
+
+function HashMap() {
+ this.map = {};
+ this.keys = [];
+}
+
+HashMap.prototype.put = function (key, value) {
+ var theId = UniqueIDGeneretor.createID(key);
+ if (!this.contains(theId)) {
+ this.map[theId] = value;
+ this.keys.push(key);
+ }
+};
+
+HashMap.prototype.contains = function (key) {
+ var theId = UniqueIDGeneretor.createID(key);
+ return this.map[key] != null;
+};
+
+HashMap.prototype.get = function (key) {
+ var theId = UniqueIDGeneretor.createID(key);
+ return this.map[theId];
+};
+
+HashMap.prototype.keySet = function () {
+ return this.keys;
+};
+
+module.exports = HashMap;
+
+/***/ }),
+/* 23 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+var UniqueIDGeneretor = __webpack_require__(14);
+
+function HashSet() {
+ this.set = {};
+}
+;
+
+HashSet.prototype.add = function (obj) {
+ var theId = UniqueIDGeneretor.createID(obj);
+ if (!this.contains(theId)) this.set[theId] = obj;
+};
+
+HashSet.prototype.remove = function (obj) {
+ delete this.set[UniqueIDGeneretor.createID(obj)];
+};
+
+HashSet.prototype.clear = function () {
+ this.set = {};
+};
+
+HashSet.prototype.contains = function (obj) {
+ return this.set[UniqueIDGeneretor.createID(obj)] == obj;
+};
+
+HashSet.prototype.isEmpty = function () {
+ return this.size() === 0;
+};
+
+HashSet.prototype.size = function () {
+ return Object.keys(this.set).length;
+};
+
+//concats this.set to the given list
+HashSet.prototype.addAllTo = function (list) {
+ var keys = Object.keys(this.set);
+ var length = keys.length;
+ for (var i = 0; i < length; i++) {
+ list.push(this.set[keys[i]]);
+ }
+};
+
+HashSet.prototype.size = function () {
+ return Object.keys(this.set).length;
+};
+
+HashSet.prototype.addAll = function (list) {
+ var s = list.length;
+ for (var i = 0; i < s; i++) {
+ var v = list[i];
+ this.add(v);
+ }
+};
+
+module.exports = HashSet;
+
+/***/ }),
+/* 24 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+// Some matrix (1d and 2d array) operations
+function Matrix() {}
+
+/**
+ * matrix multiplication
+ * array1, array2 and result are 2d arrays
+ */
+Matrix.multMat = function (array1, array2) {
+ var result = [];
+
+ for (var i = 0; i < array1.length; i++) {
+ result[i] = [];
+ for (var j = 0; j < array2[0].length; j++) {
+ result[i][j] = 0;
+ for (var k = 0; k < array1[0].length; k++) {
+ result[i][j] += array1[i][k] * array2[k][j];
+ }
+ }
+ }
+ return result;
+};
+
+/**
+ * matrix transpose
+ * array and result are 2d arrays
+ */
+Matrix.transpose = function (array) {
+ var result = [];
+
+ for (var i = 0; i < array[0].length; i++) {
+ result[i] = [];
+ for (var j = 0; j < array.length; j++) {
+ result[i][j] = array[j][i];
+ }
+ }
+
+ return result;
+};
+
+/**
+ * multiply array with constant
+ * array and result are 1d arrays
+ */
+Matrix.multCons = function (array, constant) {
+ var result = [];
+
+ for (var i = 0; i < array.length; i++) {
+ result[i] = array[i] * constant;
+ }
+
+ return result;
+};
+
+/**
+ * substract two arrays
+ * array1, array2 and result are 1d arrays
+ */
+Matrix.minusOp = function (array1, array2) {
+ var result = [];
+
+ for (var i = 0; i < array1.length; i++) {
+ result[i] = array1[i] - array2[i];
+ }
+
+ return result;
+};
+
+/**
+ * dot product of two arrays with same size
+ * array1 and array2 are 1d arrays
+ */
+Matrix.dotProduct = function (array1, array2) {
+ var product = 0;
+
+ for (var i = 0; i < array1.length; i++) {
+ product += array1[i] * array2[i];
+ }
+
+ return product;
+};
+
+/**
+ * magnitude of an array
+ * array is 1d array
+ */
+Matrix.mag = function (array) {
+ return Math.sqrt(this.dotProduct(array, array));
+};
+
+/**
+ * normalization of an array
+ * array and result are 1d array
+ */
+Matrix.normalize = function (array) {
+ var result = [];
+ var magnitude = this.mag(array);
+
+ for (var i = 0; i < array.length; i++) {
+ result[i] = array[i] / magnitude;
+ }
+
+ return result;
+};
+
+/**
+ * multiply an array with centering matrix
+ * array and result are 1d array
+ */
+Matrix.multGamma = function (array) {
+ var result = [];
+ var sum = 0;
+
+ for (var i = 0; i < array.length; i++) {
+ sum += array[i];
+ }
+
+ sum *= -1 / array.length;
+
+ for (var _i = 0; _i < array.length; _i++) {
+ result[_i] = sum + array[_i];
+ }
+ return result;
+};
+
+/**
+ * a special matrix multiplication
+ * result = 0.5 * C * INV * C^T * array
+ * array and result are 1d, C and INV are 2d arrays
+ */
+Matrix.multL = function (array, C, INV) {
+ var result = [];
+ var temp1 = [];
+ var temp2 = [];
+
+ // multiply by C^T
+ for (var i = 0; i < C[0].length; i++) {
+ var sum = 0;
+ for (var j = 0; j < C.length; j++) {
+ sum += -0.5 * C[j][i] * array[j];
+ }
+ temp1[i] = sum;
+ }
+ // multiply the result by INV
+ for (var _i2 = 0; _i2 < INV.length; _i2++) {
+ var _sum = 0;
+ for (var _j = 0; _j < INV.length; _j++) {
+ _sum += INV[_i2][_j] * temp1[_j];
+ }
+ temp2[_i2] = _sum;
+ }
+ // multiply the result by C
+ for (var _i3 = 0; _i3 < C.length; _i3++) {
+ var _sum2 = 0;
+ for (var _j2 = 0; _j2 < C[0].length; _j2++) {
+ _sum2 += C[_i3][_j2] * temp2[_j2];
+ }
+ result[_i3] = _sum2;
+ }
+
+ return result;
+};
+
+module.exports = Matrix;
+
+/***/ }),
+/* 25 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"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"); } }
+
+/**
+ * A classic Quicksort algorithm with Hoare's partition
+ * - Works also on LinkedList objects
+ *
+ * Copyright: i-Vis Research Group, Bilkent University, 2007 - present
+ */
+
+var LinkedList = __webpack_require__(11);
+
+var Quicksort = function () {
+ function Quicksort(A, compareFunction) {
+ _classCallCheck(this, Quicksort);
+
+ if (compareFunction !== null || compareFunction !== undefined) this.compareFunction = this._defaultCompareFunction;
+
+ var length = void 0;
+ if (A instanceof LinkedList) length = A.size();else length = A.length;
+
+ this._quicksort(A, 0, length - 1);
+ }
+
+ _createClass(Quicksort, [{
+ key: '_quicksort',
+ value: function _quicksort(A, p, r) {
+ if (p < r) {
+ var q = this._partition(A, p, r);
+ this._quicksort(A, p, q);
+ this._quicksort(A, q + 1, r);
+ }
+ }
+ }, {
+ key: '_partition',
+ value: function _partition(A, p, r) {
+ var x = this._get(A, p);
+ var i = p;
+ var j = r;
+ while (true) {
+ while (this.compareFunction(x, this._get(A, j))) {
+ j--;
+ }while (this.compareFunction(this._get(A, i), x)) {
+ i++;
+ }if (i < j) {
+ this._swap(A, i, j);
+ i++;
+ j--;
+ } else return j;
+ }
+ }
+ }, {
+ key: '_get',
+ value: function _get(object, index) {
+ if (object instanceof LinkedList) return object.get_object_at(index);else return object[index];
+ }
+ }, {
+ key: '_set',
+ value: function _set(object, index, value) {
+ if (object instanceof LinkedList) object.set_object_at(index, value);else object[index] = value;
+ }
+ }, {
+ key: '_swap',
+ value: function _swap(A, i, j) {
+ var temp = this._get(A, i);
+ this._set(A, i, this._get(A, j));
+ this._set(A, j, temp);
+ }
+ }, {
+ key: '_defaultCompareFunction',
+ value: function _defaultCompareFunction(a, b) {
+ return b > a;
+ }
+ }]);
+
+ return Quicksort;
+}();
+
+module.exports = Quicksort;
+
+/***/ }),
+/* 26 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+// Singular Value Decomposition implementation
+function SVD() {};
+
+/* Below singular value decomposition (svd) code including hypot function is adopted from https://github.com/dragonfly-ai/JamaJS
+ Some changes are applied to make the code compatible with the fcose code and to make it independent from Jama.
+ Input matrix is changed to a 2D array instead of Jama matrix. Matrix dimensions are taken according to 2D array instead of using Jama functions.
+ An object that includes singular value components is created for return.
+ The types of input parameters of the hypot function are removed.
+ let is used instead of var for the variable initialization.
+*/
+/*
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+ 2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+ 4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+ 6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+ 8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+ END OF TERMS AND CONDITIONS
+
+ APPENDIX: How to apply the Apache License to your work.
+
+ To apply the Apache License to your work, attach the following
+ boilerplate notice, with the fields enclosed by brackets "{}"
+ replaced with your own identifying information. (Don't include
+ the brackets!) The text should be enclosed in the appropriate
+ comment syntax for the file format. We also recommend that a
+ file or class name and description of purpose be included on the
+ same "printed page" as the copyright notice for easier
+ identification within third-party archives.
+
+ Copyright {yyyy} {name of copyright owner}
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+*/
+
+SVD.svd = function (A) {
+ this.U = null;
+ this.V = null;
+ this.s = null;
+ this.m = 0;
+ this.n = 0;
+ this.m = A.length;
+ this.n = A[0].length;
+ var nu = Math.min(this.m, this.n);
+ this.s = function (s) {
+ var a = [];
+ while (s-- > 0) {
+ a.push(0);
+ }return a;
+ }(Math.min(this.m + 1, this.n));
+ this.U = function (dims) {
+ var allocate = function allocate(dims) {
+ if (dims.length == 0) {
+ return 0;
+ } else {
+ var array = [];
+ for (var i = 0; i < dims[0]; i++) {
+ array.push(allocate(dims.slice(1)));
+ }
+ return array;
+ }
+ };
+ return allocate(dims);
+ }([this.m, nu]);
+ this.V = function (dims) {
+ var allocate = function allocate(dims) {
+ if (dims.length == 0) {
+ return 0;
+ } else {
+ var array = [];
+ for (var i = 0; i < dims[0]; i++) {
+ array.push(allocate(dims.slice(1)));
+ }
+ return array;
+ }
+ };
+ return allocate(dims);
+ }([this.n, this.n]);
+ var e = function (s) {
+ var a = [];
+ while (s-- > 0) {
+ a.push(0);
+ }return a;
+ }(this.n);
+ var work = function (s) {
+ var a = [];
+ while (s-- > 0) {
+ a.push(0);
+ }return a;
+ }(this.m);
+ var wantu = true;
+ var wantv = true;
+ var nct = Math.min(this.m - 1, this.n);
+ var nrt = Math.max(0, Math.min(this.n - 2, this.m));
+ for (var k = 0; k < Math.max(nct, nrt); k++) {
+ if (k < nct) {
+ this.s[k] = 0;
+ for (var i = k; i < this.m; i++) {
+ this.s[k] = SVD.hypot(this.s[k], A[i][k]);
+ }
+ ;
+ if (this.s[k] !== 0.0) {
+ if (A[k][k] < 0.0) {
+ this.s[k] = -this.s[k];
+ }
+ for (var _i = k; _i < this.m; _i++) {
+ A[_i][k] /= this.s[k];
+ }
+ ;
+ A[k][k] += 1.0;
+ }
+ this.s[k] = -this.s[k];
+ }
+ for (var j = k + 1; j < this.n; j++) {
+ if (function (lhs, rhs) {
+ return lhs && rhs;
+ }(k < nct, this.s[k] !== 0.0)) {
+ var t = 0;
+ for (var _i2 = k; _i2 < this.m; _i2++) {
+ t += A[_i2][k] * A[_i2][j];
+ }
+ ;
+ t = -t / A[k][k];
+ for (var _i3 = k; _i3 < this.m; _i3++) {
+ A[_i3][j] += t * A[_i3][k];
+ }
+ ;
+ }
+ e[j] = A[k][j];
+ }
+ ;
+ if (function (lhs, rhs) {
+ return lhs && rhs;
+ }(wantu, k < nct)) {
+ for (var _i4 = k; _i4 < this.m; _i4++) {
+ this.U[_i4][k] = A[_i4][k];
+ }
+ ;
+ }
+ if (k < nrt) {
+ e[k] = 0;
+ for (var _i5 = k + 1; _i5 < this.n; _i5++) {
+ e[k] = SVD.hypot(e[k], e[_i5]);
+ }
+ ;
+ if (e[k] !== 0.0) {
+ if (e[k + 1] < 0.0) {
+ e[k] = -e[k];
+ }
+ for (var _i6 = k + 1; _i6 < this.n; _i6++) {
+ e[_i6] /= e[k];
+ }
+ ;
+ e[k + 1] += 1.0;
+ }
+ e[k] = -e[k];
+ if (function (lhs, rhs) {
+ return lhs && rhs;
+ }(k + 1 < this.m, e[k] !== 0.0)) {
+ for (var _i7 = k + 1; _i7 < this.m; _i7++) {
+ work[_i7] = 0.0;
+ }
+ ;
+ for (var _j = k + 1; _j < this.n; _j++) {
+ for (var _i8 = k + 1; _i8 < this.m; _i8++) {
+ work[_i8] += e[_j] * A[_i8][_j];
+ }
+ ;
+ }
+ ;
+ for (var _j2 = k + 1; _j2 < this.n; _j2++) {
+ var _t = -e[_j2] / e[k + 1];
+ for (var _i9 = k + 1; _i9 < this.m; _i9++) {
+ A[_i9][_j2] += _t * work[_i9];
+ }
+ ;
+ }
+ ;
+ }
+ if (wantv) {
+ for (var _i10 = k + 1; _i10 < this.n; _i10++) {
+ this.V[_i10][k] = e[_i10];
+ };
+ }
+ }
+ };
+ var p = Math.min(this.n, this.m + 1);
+ if (nct < this.n) {
+ this.s[nct] = A[nct][nct];
+ }
+ if (this.m < p) {
+ this.s[p - 1] = 0.0;
+ }
+ if (nrt + 1 < p) {
+ e[nrt] = A[nrt][p - 1];
+ }
+ e[p - 1] = 0.0;
+ if (wantu) {
+ for (var _j3 = nct; _j3 < nu; _j3++) {
+ for (var _i11 = 0; _i11 < this.m; _i11++) {
+ this.U[_i11][_j3] = 0.0;
+ }
+ ;
+ this.U[_j3][_j3] = 1.0;
+ };
+ for (var _k = nct - 1; _k >= 0; _k--) {
+ if (this.s[_k] !== 0.0) {
+ for (var _j4 = _k + 1; _j4 < nu; _j4++) {
+ var _t2 = 0;
+ for (var _i12 = _k; _i12 < this.m; _i12++) {
+ _t2 += this.U[_i12][_k] * this.U[_i12][_j4];
+ };
+ _t2 = -_t2 / this.U[_k][_k];
+ for (var _i13 = _k; _i13 < this.m; _i13++) {
+ this.U[_i13][_j4] += _t2 * this.U[_i13][_k];
+ };
+ };
+ for (var _i14 = _k; _i14 < this.m; _i14++) {
+ this.U[_i14][_k] = -this.U[_i14][_k];
+ };
+ this.U[_k][_k] = 1.0 + this.U[_k][_k];
+ for (var _i15 = 0; _i15 < _k - 1; _i15++) {
+ this.U[_i15][_k] = 0.0;
+ };
+ } else {
+ for (var _i16 = 0; _i16 < this.m; _i16++) {
+ this.U[_i16][_k] = 0.0;
+ };
+ this.U[_k][_k] = 1.0;
+ }
+ };
+ }
+ if (wantv) {
+ for (var _k2 = this.n - 1; _k2 >= 0; _k2--) {
+ if (function (lhs, rhs) {
+ return lhs && rhs;
+ }(_k2 < nrt, e[_k2] !== 0.0)) {
+ for (var _j5 = _k2 + 1; _j5 < nu; _j5++) {
+ var _t3 = 0;
+ for (var _i17 = _k2 + 1; _i17 < this.n; _i17++) {
+ _t3 += this.V[_i17][_k2] * this.V[_i17][_j5];
+ };
+ _t3 = -_t3 / this.V[_k2 + 1][_k2];
+ for (var _i18 = _k2 + 1; _i18 < this.n; _i18++) {
+ this.V[_i18][_j5] += _t3 * this.V[_i18][_k2];
+ };
+ };
+ }
+ for (var _i19 = 0; _i19 < this.n; _i19++) {
+ this.V[_i19][_k2] = 0.0;
+ };
+ this.V[_k2][_k2] = 1.0;
+ };
+ }
+ var pp = p - 1;
+ var iter = 0;
+ var eps = Math.pow(2.0, -52.0);
+ var tiny = Math.pow(2.0, -966.0);
+ while (p > 0) {
+ var _k3 = void 0;
+ var kase = void 0;
+ for (_k3 = p - 2; _k3 >= -1; _k3--) {
+ if (_k3 === -1) {
+ break;
+ }
+ if (Math.abs(e[_k3]) <= tiny + eps * (Math.abs(this.s[_k3]) + Math.abs(this.s[_k3 + 1]))) {
+ e[_k3] = 0.0;
+ break;
+ }
+ };
+ if (_k3 === p - 2) {
+ kase = 4;
+ } else {
+ var ks = void 0;
+ for (ks = p - 1; ks >= _k3; ks--) {
+ if (ks === _k3) {
+ break;
+ }
+ var _t4 = (ks !== p ? Math.abs(e[ks]) : 0.0) + (ks !== _k3 + 1 ? Math.abs(e[ks - 1]) : 0.0);
+ if (Math.abs(this.s[ks]) <= tiny + eps * _t4) {
+ this.s[ks] = 0.0;
+ break;
+ }
+ };
+ if (ks === _k3) {
+ kase = 3;
+ } else if (ks === p - 1) {
+ kase = 1;
+ } else {
+ kase = 2;
+ _k3 = ks;
+ }
+ }
+ _k3++;
+ switch (kase) {
+ case 1:
+ {
+ var f = e[p - 2];
+ e[p - 2] = 0.0;
+ for (var _j6 = p - 2; _j6 >= _k3; _j6--) {
+ var _t5 = SVD.hypot(this.s[_j6], f);
+ var cs = this.s[_j6] / _t5;
+ var sn = f / _t5;
+ this.s[_j6] = _t5;
+ if (_j6 !== _k3) {
+ f = -sn * e[_j6 - 1];
+ e[_j6 - 1] = cs * e[_j6 - 1];
+ }
+ if (wantv) {
+ for (var _i20 = 0; _i20 < this.n; _i20++) {
+ _t5 = cs * this.V[_i20][_j6] + sn * this.V[_i20][p - 1];
+ this.V[_i20][p - 1] = -sn * this.V[_i20][_j6] + cs * this.V[_i20][p - 1];
+ this.V[_i20][_j6] = _t5;
+ };
+ }
+ };
+ };
+ break;
+ case 2:
+ {
+ var _f = e[_k3 - 1];
+ e[_k3 - 1] = 0.0;
+ for (var _j7 = _k3; _j7 < p; _j7++) {
+ var _t6 = SVD.hypot(this.s[_j7], _f);
+ var _cs = this.s[_j7] / _t6;
+ var _sn = _f / _t6;
+ this.s[_j7] = _t6;
+ _f = -_sn * e[_j7];
+ e[_j7] = _cs * e[_j7];
+ if (wantu) {
+ for (var _i21 = 0; _i21 < this.m; _i21++) {
+ _t6 = _cs * this.U[_i21][_j7] + _sn * this.U[_i21][_k3 - 1];
+ this.U[_i21][_k3 - 1] = -_sn * this.U[_i21][_j7] + _cs * this.U[_i21][_k3 - 1];
+ this.U[_i21][_j7] = _t6;
+ };
+ }
+ };
+ };
+ break;
+ case 3:
+ {
+ var scale = Math.max(Math.max(Math.max(Math.max(Math.abs(this.s[p - 1]), Math.abs(this.s[p - 2])), Math.abs(e[p - 2])), Math.abs(this.s[_k3])), Math.abs(e[_k3]));
+ var sp = this.s[p - 1] / scale;
+ var spm1 = this.s[p - 2] / scale;
+ var epm1 = e[p - 2] / scale;
+ var sk = this.s[_k3] / scale;
+ var ek = e[_k3] / scale;
+ var b = ((spm1 + sp) * (spm1 - sp) + epm1 * epm1) / 2.0;
+ var c = sp * epm1 * (sp * epm1);
+ var shift = 0.0;
+ if (function (lhs, rhs) {
+ return lhs || rhs;
+ }(b !== 0.0, c !== 0.0)) {
+ shift = Math.sqrt(b * b + c);
+ if (b < 0.0) {
+ shift = -shift;
+ }
+ shift = c / (b + shift);
+ }
+ var _f2 = (sk + sp) * (sk - sp) + shift;
+ var g = sk * ek;
+ for (var _j8 = _k3; _j8 < p - 1; _j8++) {
+ var _t7 = SVD.hypot(_f2, g);
+ var _cs2 = _f2 / _t7;
+ var _sn2 = g / _t7;
+ if (_j8 !== _k3) {
+ e[_j8 - 1] = _t7;
+ }
+ _f2 = _cs2 * this.s[_j8] + _sn2 * e[_j8];
+ e[_j8] = _cs2 * e[_j8] - _sn2 * this.s[_j8];
+ g = _sn2 * this.s[_j8 + 1];
+ this.s[_j8 + 1] = _cs2 * this.s[_j8 + 1];
+ if (wantv) {
+ for (var _i22 = 0; _i22 < this.n; _i22++) {
+ _t7 = _cs2 * this.V[_i22][_j8] + _sn2 * this.V[_i22][_j8 + 1];
+ this.V[_i22][_j8 + 1] = -_sn2 * this.V[_i22][_j8] + _cs2 * this.V[_i22][_j8 + 1];
+ this.V[_i22][_j8] = _t7;
+ };
+ }
+ _t7 = SVD.hypot(_f2, g);
+ _cs2 = _f2 / _t7;
+ _sn2 = g / _t7;
+ this.s[_j8] = _t7;
+ _f2 = _cs2 * e[_j8] + _sn2 * this.s[_j8 + 1];
+ this.s[_j8 + 1] = -_sn2 * e[_j8] + _cs2 * this.s[_j8 + 1];
+ g = _sn2 * e[_j8 + 1];
+ e[_j8 + 1] = _cs2 * e[_j8 + 1];
+ if (wantu && _j8 < this.m - 1) {
+ for (var _i23 = 0; _i23 < this.m; _i23++) {
+ _t7 = _cs2 * this.U[_i23][_j8] + _sn2 * this.U[_i23][_j8 + 1];
+ this.U[_i23][_j8 + 1] = -_sn2 * this.U[_i23][_j8] + _cs2 * this.U[_i23][_j8 + 1];
+ this.U[_i23][_j8] = _t7;
+ };
+ }
+ };
+ e[p - 2] = _f2;
+ iter = iter + 1;
+ };
+ break;
+ case 4:
+ {
+ if (this.s[_k3] <= 0.0) {
+ this.s[_k3] = this.s[_k3] < 0.0 ? -this.s[_k3] : 0.0;
+ if (wantv) {
+ for (var _i24 = 0; _i24 <= pp; _i24++) {
+ this.V[_i24][_k3] = -this.V[_i24][_k3];
+ };
+ }
+ }
+ while (_k3 < pp) {
+ if (this.s[_k3] >= this.s[_k3 + 1]) {
+ break;
+ }
+ var _t8 = this.s[_k3];
+ this.s[_k3] = this.s[_k3 + 1];
+ this.s[_k3 + 1] = _t8;
+ if (wantv && _k3 < this.n - 1) {
+ for (var _i25 = 0; _i25 < this.n; _i25++) {
+ _t8 = this.V[_i25][_k3 + 1];
+ this.V[_i25][_k3 + 1] = this.V[_i25][_k3];
+ this.V[_i25][_k3] = _t8;
+ };
+ }
+ if (wantu && _k3 < this.m - 1) {
+ for (var _i26 = 0; _i26 < this.m; _i26++) {
+ _t8 = this.U[_i26][_k3 + 1];
+ this.U[_i26][_k3 + 1] = this.U[_i26][_k3];
+ this.U[_i26][_k3] = _t8;
+ };
+ }
+ _k3++;
+ };
+ iter = 0;
+ p--;
+ };
+ break;
+ }
+ };
+ var result = { U: this.U, V: this.V, S: this.s };
+ return result;
+};
+
+// sqrt(a^2 + b^2) without under/overflow.
+SVD.hypot = function (a, b) {
+ var r = void 0;
+ if (Math.abs(a) > Math.abs(b)) {
+ r = b / a;
+ r = Math.abs(a) * Math.sqrt(1 + r * r);
+ } else if (b != 0) {
+ r = a / b;
+ r = Math.abs(b) * Math.sqrt(1 + r * r);
+ } else {
+ r = 0.0;
+ }
+ return r;
+};
+
+module.exports = SVD;
+
+/***/ }),
+/* 27 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"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"); } }
+
+/**
+ * Needleman-Wunsch algorithm is an procedure to compute the optimal global alignment of two string
+ * sequences by S.B.Needleman and C.D.Wunsch (1970).
+ *
+ * Aside from the inputs, you can assign the scores for,
+ * - Match: The two characters at the current index are same.
+ * - Mismatch: The two characters at the current index are different.
+ * - Insertion/Deletion(gaps): The best alignment involves one letter aligning to a gap in the other string.
+ */
+
+var NeedlemanWunsch = function () {
+ function NeedlemanWunsch(sequence1, sequence2) {
+ var match_score = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1;
+ var mismatch_penalty = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : -1;
+ var gap_penalty = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : -1;
+
+ _classCallCheck(this, NeedlemanWunsch);
+
+ this.sequence1 = sequence1;
+ this.sequence2 = sequence2;
+ this.match_score = match_score;
+ this.mismatch_penalty = mismatch_penalty;
+ this.gap_penalty = gap_penalty;
+
+ // Just the remove redundancy
+ this.iMax = sequence1.length + 1;
+ this.jMax = sequence2.length + 1;
+
+ // Grid matrix of scores
+ this.grid = new Array(this.iMax);
+ for (var i = 0; i < this.iMax; i++) {
+ this.grid[i] = new Array(this.jMax);
+
+ for (var j = 0; j < this.jMax; j++) {
+ this.grid[i][j] = 0;
+ }
+ }
+
+ // Traceback matrix (2D array, each cell is an array of boolean values for [`Diag`, `Up`, `Left`] positions)
+ this.tracebackGrid = new Array(this.iMax);
+ for (var _i = 0; _i < this.iMax; _i++) {
+ this.tracebackGrid[_i] = new Array(this.jMax);
+
+ for (var _j = 0; _j < this.jMax; _j++) {
+ this.tracebackGrid[_i][_j] = [null, null, null];
+ }
+ }
+
+ // The aligned sequences (return multiple possibilities)
+ this.alignments = [];
+
+ // Final alignment score
+ this.score = -1;
+
+ // Calculate scores and tracebacks
+ this.computeGrids();
+ }
+
+ _createClass(NeedlemanWunsch, [{
+ key: "getScore",
+ value: function getScore() {
+ return this.score;
+ }
+ }, {
+ key: "getAlignments",
+ value: function getAlignments() {
+ return this.alignments;
+ }
+
+ // Main dynamic programming procedure
+
+ }, {
+ key: "computeGrids",
+ value: function computeGrids() {
+ // Fill in the first row
+ for (var j = 1; j < this.jMax; j++) {
+ this.grid[0][j] = this.grid[0][j - 1] + this.gap_penalty;
+ this.tracebackGrid[0][j] = [false, false, true];
+ }
+
+ // Fill in the first column
+ for (var i = 1; i < this.iMax; i++) {
+ this.grid[i][0] = this.grid[i - 1][0] + this.gap_penalty;
+ this.tracebackGrid[i][0] = [false, true, false];
+ }
+
+ // Fill the rest of the grid
+ for (var _i2 = 1; _i2 < this.iMax; _i2++) {
+ for (var _j2 = 1; _j2 < this.jMax; _j2++) {
+ // Find the max score(s) among [`Diag`, `Up`, `Left`]
+ var diag = void 0;
+ if (this.sequence1[_i2 - 1] === this.sequence2[_j2 - 1]) diag = this.grid[_i2 - 1][_j2 - 1] + this.match_score;else diag = this.grid[_i2 - 1][_j2 - 1] + this.mismatch_penalty;
+
+ var up = this.grid[_i2 - 1][_j2] + this.gap_penalty;
+ var left = this.grid[_i2][_j2 - 1] + this.gap_penalty;
+
+ // If there exists multiple max values, capture them for multiple paths
+ var maxOf = [diag, up, left];
+ var indices = this.arrayAllMaxIndexes(maxOf);
+
+ // Update Grids
+ this.grid[_i2][_j2] = maxOf[indices[0]];
+ this.tracebackGrid[_i2][_j2] = [indices.includes(0), indices.includes(1), indices.includes(2)];
+ }
+ }
+
+ // Update alignment score
+ this.score = this.grid[this.iMax - 1][this.jMax - 1];
+ }
+
+ // Gets all possible valid sequence combinations
+
+ }, {
+ key: "alignmentTraceback",
+ value: function alignmentTraceback() {
+ var inProcessAlignments = [];
+
+ inProcessAlignments.push({ pos: [this.sequence1.length, this.sequence2.length],
+ seq1: "",
+ seq2: ""
+ });
+
+ while (inProcessAlignments[0]) {
+ var current = inProcessAlignments[0];
+ var directions = this.tracebackGrid[current.pos[0]][current.pos[1]];
+
+ if (directions[0]) {
+ inProcessAlignments.push({ pos: [current.pos[0] - 1, current.pos[1] - 1],
+ seq1: this.sequence1[current.pos[0] - 1] + current.seq1,
+ seq2: this.sequence2[current.pos[1] - 1] + current.seq2
+ });
+ }
+ if (directions[1]) {
+ inProcessAlignments.push({ pos: [current.pos[0] - 1, current.pos[1]],
+ seq1: this.sequence1[current.pos[0] - 1] + current.seq1,
+ seq2: '-' + current.seq2
+ });
+ }
+ if (directions[2]) {
+ inProcessAlignments.push({ pos: [current.pos[0], current.pos[1] - 1],
+ seq1: '-' + current.seq1,
+ seq2: this.sequence2[current.pos[1] - 1] + current.seq2
+ });
+ }
+
+ if (current.pos[0] === 0 && current.pos[1] === 0) this.alignments.push({ sequence1: current.seq1,
+ sequence2: current.seq2
+ });
+
+ inProcessAlignments.shift();
+ }
+
+ return this.alignments;
+ }
+
+ // Helper Functions
+
+ }, {
+ key: "getAllIndexes",
+ value: function getAllIndexes(arr, val) {
+ var indexes = [],
+ i = -1;
+ while ((i = arr.indexOf(val, i + 1)) !== -1) {
+ indexes.push(i);
+ }
+ return indexes;
+ }
+ }, {
+ key: "arrayAllMaxIndexes",
+ value: function arrayAllMaxIndexes(array) {
+ return this.getAllIndexes(array, Math.max.apply(null, array));
+ }
+ }]);
+
+ return NeedlemanWunsch;
+}();
+
+module.exports = NeedlemanWunsch;
+
+/***/ }),
+/* 28 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+var layoutBase = function layoutBase() {
+ return;
+};
+
+layoutBase.FDLayout = __webpack_require__(18);
+layoutBase.FDLayoutConstants = __webpack_require__(4);
+layoutBase.FDLayoutEdge = __webpack_require__(19);
+layoutBase.FDLayoutNode = __webpack_require__(20);
+layoutBase.DimensionD = __webpack_require__(21);
+layoutBase.HashMap = __webpack_require__(22);
+layoutBase.HashSet = __webpack_require__(23);
+layoutBase.IGeometry = __webpack_require__(8);
+layoutBase.IMath = __webpack_require__(9);
+layoutBase.Integer = __webpack_require__(10);
+layoutBase.Point = __webpack_require__(12);
+layoutBase.PointD = __webpack_require__(5);
+layoutBase.RandomSeed = __webpack_require__(16);
+layoutBase.RectangleD = __webpack_require__(13);
+layoutBase.Transform = __webpack_require__(17);
+layoutBase.UniqueIDGeneretor = __webpack_require__(14);
+layoutBase.Quicksort = __webpack_require__(25);
+layoutBase.LinkedList = __webpack_require__(11);
+layoutBase.LGraphObject = __webpack_require__(2);
+layoutBase.LGraph = __webpack_require__(6);
+layoutBase.LEdge = __webpack_require__(1);
+layoutBase.LGraphManager = __webpack_require__(7);
+layoutBase.LNode = __webpack_require__(3);
+layoutBase.Layout = __webpack_require__(15);
+layoutBase.LayoutConstants = __webpack_require__(0);
+layoutBase.NeedlemanWunsch = __webpack_require__(27);
+layoutBase.Matrix = __webpack_require__(24);
+layoutBase.SVD = __webpack_require__(26);
+
+module.exports = layoutBase;
+
+/***/ }),
+/* 29 */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+
+function Emitter() {
+ this.listeners = [];
+}
+
+var p = Emitter.prototype;
+
+p.addListener = function (event, callback) {
+ this.listeners.push({
+ event: event,
+ callback: callback
+ });
+};
+
+p.removeListener = function (event, callback) {
+ for (var i = this.listeners.length; i >= 0; i--) {
+ var l = this.listeners[i];
+
+ if (l.event === event && l.callback === callback) {
+ this.listeners.splice(i, 1);
+ }
+ }
+};
+
+p.emit = function (event, data) {
+ for (var i = 0; i < this.listeners.length; i++) {
+ var l = this.listeners[i];
+
+ if (event === l.event) {
+ l.callback(data);
+ }
+ }
+};
+
+module.exports = Emitter;
+
+/***/ })
+/******/ ]);
+});
\ No newline at end of file
diff --git a/langs/de_DE/kundenkarte.lang b/langs/de_DE/kundenkarte.lang
index d4c6200..b00a44f 100755
--- a/langs/de_DE/kundenkarte.lang
+++ b/langs/de_DE/kundenkarte.lang
@@ -322,6 +322,19 @@ ErrorNoFileSelected = Keine Datei ausgewaehlt
PDFTemplateHelp = Laden Sie eine PDF-Datei als Hintergrund/Briefpapier fuer den Export hoch. Die erste Seite wird als Vorlage verwendet.
ExportTreeAsPDF = Als PDF exportieren
+# View Mode
+DefaultViewMode = Standard-Ansichtsmodus fuer Anlagen
+ViewModeTree = Baumansicht (klassisch)
+ViewModeGraph = Graph-Ansicht (Cytoscape)
+SpatialView = Raeumlich
+TechnicalView = Technisch
+GraphLoading = Graph wird geladen...
+GraphLegendRoom = Raum/Gebaeude
+GraphLegendDevice = Geraet
+GraphLegendCable = Kabel
+GraphLegendPassthrough = Durchgeschleift
+GraphLegendHierarchy = Hierarchie
+
# Tree Display Settings
TreeDisplaySettings = Baum-Anzeige Einstellungen
TreeInfoDisplayMode = Zusatzinfos-Anzeige
diff --git a/langs/en_US/kundenkarte.lang b/langs/en_US/kundenkarte.lang
index 99441a1..3eaaa3f 100755
--- a/langs/en_US/kundenkarte.lang
+++ b/langs/en_US/kundenkarte.lang
@@ -187,6 +187,19 @@ ErrorNoFileSelected = No file selected
PDFTemplateHelp = Upload a PDF file as background/letterhead for export. The first page will be used as template.
ExportTreeAsPDF = Export as PDF
+# View Mode
+DefaultViewMode = Default view mode for installations
+ViewModeTree = Tree view (classic)
+ViewModeGraph = Graph view (Cytoscape)
+SpatialView = Spatial
+TechnicalView = Technical
+GraphLoading = Loading graph...
+GraphLegendRoom = Room/Building
+GraphLegendDevice = Device
+GraphLegendCable = Cable
+GraphLegendPassthrough = Passthrough
+GraphLegendHierarchy = Hierarchy
+
# Tree Display Settings
TreeDisplaySettings = Tree Display Settings
TreeInfoDisplayMode = Info Display Mode
diff --git a/sql/llx_kundenkarte_anlage.sql b/sql/llx_kundenkarte_anlage.sql
index a66af9f..f292240 100755
--- a/sql/llx_kundenkarte_anlage.sql
+++ b/sql/llx_kundenkarte_anlage.sql
@@ -18,6 +18,7 @@ CREATE TABLE llx_kundenkarte_anlage
fk_parent integer DEFAULT 0 NOT NULL,
fk_system integer NOT NULL,
+ fk_building_node integer DEFAULT 0,
manufacturer varchar(128),
model varchar(128),
diff --git a/tabs/anlagen.php b/tabs/anlagen.php
index 3e3241c..dd9c172 100755
--- a/tabs/anlagen.php
+++ b/tabs/anlagen.php
@@ -365,7 +365,24 @@ if ($action == 'togglepin' && $permissiontoadd) {
// Use Dolibarr standard button classes
$title = $langs->trans('TechnicalInstallations').' - '.$object->name;
-llxHeader('', $title, '', '', 0, 0, array('/kundenkarte/js/pathfinding.min.js', '/kundenkarte/js/kundenkarte.js?v='.time()), array('/kundenkarte/css/kundenkarte.css?v='.time()));
+
+// Ansichtsmodus (Admin-Setting)
+$viewMode = getDolGlobalString('KUNDENKARTE_DEFAULT_VIEW', 'tree');
+
+$jsFiles = array('/kundenkarte/js/kundenkarte.js?v='.time());
+$cssFiles = array('/kundenkarte/css/kundenkarte.css?v='.time());
+
+if ($viewMode === 'graph') {
+ $jsFiles[] = '/kundenkarte/js/dagre.min.js';
+ $jsFiles[] = '/kundenkarte/js/cytoscape.min.js';
+ $jsFiles[] = '/kundenkarte/js/cytoscape-dagre.js';
+ $jsFiles[] = '/kundenkarte/js/kundenkarte_cytoscape.js?v='.time();
+ $cssFiles[] = '/kundenkarte/css/kundenkarte_cytoscape.css?v='.time();
+} else {
+ array_unshift($jsFiles, '/kundenkarte/js/pathfinding.min.js');
+}
+
+llxHeader('', $title, '', '', 0, 0, $jsFiles, $cssFiles);
// Prepare tabs
$head = societe_prepare_head($object);
@@ -452,24 +469,43 @@ print '';
// Expand/Collapse buttons (only in tree view, not in create/edit/view/copy)
$isTreeView = !in_array($action, array('create', 'edit', 'view', 'copy'));
if ($isTreeView) {
- print '';
- // Compact mode toggle (visible on mobile)
- print '
';
- print '
';
- print '
';
- if ($systemId > 0) {
- $exportUrl = dol_buildpath('/kundenkarte/ajax/export_tree_pdf.php', 1).'?socid='.$id.'&system='.$systemId;
- print '
';
- print ' PDF Export';
- print '';
+ if ($viewMode === 'graph') {
+ // Graph Controls: Aktionen + Zoom
+ print '
';
+ } else {
+ print '
';
+ // Compact mode toggle (visible on mobile)
+ print '
';
+ print '
';
+ print '
';
+ if ($systemId > 0) {
+ $exportUrl = dol_buildpath('/kundenkarte/ajax/export_tree_pdf.php', 1).'?socid='.$id.'&system='.$systemId;
+ print '
';
+ print ' PDF Export';
+ print '';
+ }
+ print '
';
}
- print '
';
+ print '
';
+ print '
'.$langs->trans('GraphLoading').'
';
+ print '
';
- // Pre-load all connections for this customer/system
- dol_include_once('/kundenkarte/class/anlageconnection.class.php');
- $connObj = new AnlageConnection($db);
- $allConnections = $connObj->fetchBySociete($id, $systemId);
- // Index by target_id for quick lookup (connection shows ABOVE the target element)
- $connectionsByTarget = array();
- foreach ($allConnections as $conn) {
- if (!isset($connectionsByTarget[$conn->fk_target])) {
- $connectionsByTarget[$conn->fk_target] = array();
- }
- $connectionsByTarget[$conn->fk_target][] = $conn;
- }
-
- if (!empty($tree)) {
- print '
';
- printTree($tree, $id, $systemId, $permissiontoadd, $permissiontodelete, $langs, 0, $typeFieldsMap, $connectionsByTarget);
+ // Legende - wird dynamisch vom JS befüllt (Kabeltypen mit Farben)
+ print '
';
print '
';
} else {
- print '
'.$langs->trans('NoInstallations').'
';
+ // Baumansicht (klassisch)
+
+ // Load tree
+ $tree = $anlage->fetchTree($id, $systemId);
+
+ // Pre-load all type fields for tooltip and tree display
+ $typeFieldsMap = array();
+ $sql = "SELECT f.*, f.fk_anlage_type FROM ".MAIN_DB_PREFIX."kundenkarte_anlage_type_field f WHERE f.active = 1 ORDER BY f.position ASC";
+ $resql = $db->query($sql);
+ if ($resql) {
+ while ($obj = $db->fetch_object($resql)) {
+ if (!isset($typeFieldsMap[$obj->fk_anlage_type])) {
+ $typeFieldsMap[$obj->fk_anlage_type] = array();
+ }
+ $typeFieldsMap[$obj->fk_anlage_type][] = $obj;
+ }
+ $db->free($resql);
+ }
+
+ // Pre-load all connections for this customer/system
+ dol_include_once('/kundenkarte/class/anlageconnection.class.php');
+ $connObj = new AnlageConnection($db);
+ $allConnections = $connObj->fetchBySociete($id, $systemId);
+ // Index by target_id for quick lookup (connection shows ABOVE the target element)
+ $connectionsByTarget = array();
+ foreach ($allConnections as $conn) {
+ if (!isset($connectionsByTarget[$conn->fk_target])) {
+ $connectionsByTarget[$conn->fk_target] = array();
+ }
+ $connectionsByTarget[$conn->fk_target][] = $conn;
+ }
+
+ if (!empty($tree)) {
+ print '
';
+ printTree($tree, $id, $systemId, $permissiontoadd, $permissiontodelete, $langs, 0, $typeFieldsMap, $connectionsByTarget);
+ print '
';
+ } else {
+ print '
'.$langs->trans('NoInstallations').'
';
+ }
}
}
}
diff --git a/tabs/contact_anlagen.php b/tabs/contact_anlagen.php
index af7827c..e973b03 100755
--- a/tabs/contact_anlagen.php
+++ b/tabs/contact_anlagen.php
@@ -364,7 +364,24 @@ if ($action == 'togglepin' && $permissiontoadd) {
*/
$title = $langs->trans('TechnicalInstallations').' - '.$object->getFullName($langs);
-llxHeader('', $title, '', '', 0, 0, array('/kundenkarte/js/pathfinding.min.js', '/kundenkarte/js/kundenkarte.js?v='.time()), array('/kundenkarte/css/kundenkarte.css?v='.time()));
+
+// Ansichtsmodus (Admin-Setting)
+$viewMode = getDolGlobalString('KUNDENKARTE_DEFAULT_VIEW', 'tree');
+
+$jsFiles = array('/kundenkarte/js/kundenkarte.js?v='.time());
+$cssFiles = array('/kundenkarte/css/kundenkarte.css?v='.time());
+
+if ($viewMode === 'graph') {
+ $jsFiles[] = '/kundenkarte/js/dagre.min.js';
+ $jsFiles[] = '/kundenkarte/js/cytoscape.min.js';
+ $jsFiles[] = '/kundenkarte/js/cytoscape-dagre.js';
+ $jsFiles[] = '/kundenkarte/js/kundenkarte_cytoscape.js?v='.time();
+ $cssFiles[] = '/kundenkarte/css/kundenkarte_cytoscape.css?v='.time();
+} else {
+ array_unshift($jsFiles, '/kundenkarte/js/pathfinding.min.js');
+}
+
+llxHeader('', $title, '', '', 0, 0, $jsFiles, $cssFiles);
// Prepare tabs
$head = contact_prepare_head($object);
@@ -451,24 +468,43 @@ print '
';
- // Compact mode toggle (visible on mobile)
- print '
';
- print '
';
- print '
';
- if ($systemId > 0) {
- $exportUrl = dol_buildpath('/kundenkarte/ajax/export_tree_pdf.php', 1).'?socid='.$object->socid.'&contactid='.$id.'&system='.$systemId;
- print '
';
- print ' PDF Export';
- print '';
+ if ($viewMode === 'graph') {
+ // Graph Controls: Aktionen + Zoom
+ print '
';
+ } else {
+ print '
';
+ // Compact mode toggle (visible on mobile)
+ print '
';
+ print '
';
+ print '
';
+ if ($systemId > 0) {
+ $exportUrl = dol_buildpath('/kundenkarte/ajax/export_tree_pdf.php', 1).'?socid='.$object->socid.'&contactid='.$id.'&system='.$systemId;
+ print '
';
+ print ' PDF Export';
+ print '';
+ }
+ print '
';
}
- print '
';
+ print '
';
+ print '
'.$langs->trans('GraphLoading').'
';
+ print '
';
- // Pre-load all connections for this contact/system
- dol_include_once('/kundenkarte/class/anlageconnection.class.php');
- $connObj = new AnlageConnection($db);
- $allConnections = $connObj->fetchBySociete($object->socid, $systemId);
- // Index by target_id for quick lookup (connection shows ABOVE the target element)
- $connectionsByTarget = array();
- foreach ($allConnections as $conn) {
- if (!isset($connectionsByTarget[$conn->fk_target])) {
- $connectionsByTarget[$conn->fk_target] = array();
- }
- $connectionsByTarget[$conn->fk_target][] = $conn;
- }
-
- if (!empty($tree)) {
- print '
';
- printTree($tree, $id, $systemId, $permissiontoadd, $permissiontodelete, $langs, 0, $typeFieldsMap, $connectionsByTarget);
+ // Legende - wird dynamisch vom JS befüllt (Kabeltypen mit Farben)
+ print '
';
print '
';
} else {
- print '
'.$langs->trans('NoInstallations').'
';
+ // Baumansicht (klassisch)
+
+ // Load tree for this contact
+ $tree = $anlage->fetchTreeByContact($object->socid, $id, $systemId);
+
+ // Pre-load all type fields for tooltip and tree display
+ $typeFieldsMap = array();
+ $sql = "SELECT f.*, f.fk_anlage_type FROM ".MAIN_DB_PREFIX."kundenkarte_anlage_type_field f WHERE f.active = 1 ORDER BY f.position ASC";
+ $resql = $db->query($sql);
+ if ($resql) {
+ while ($obj = $db->fetch_object($resql)) {
+ if (!isset($typeFieldsMap[$obj->fk_anlage_type])) {
+ $typeFieldsMap[$obj->fk_anlage_type] = array();
+ }
+ $typeFieldsMap[$obj->fk_anlage_type][] = $obj;
+ }
+ $db->free($resql);
+ }
+
+ // Pre-load all connections for this contact/system
+ dol_include_once('/kundenkarte/class/anlageconnection.class.php');
+ $connObj = new AnlageConnection($db);
+ $allConnections = $connObj->fetchBySociete($object->socid, $systemId);
+ // Index by target_id for quick lookup (connection shows ABOVE the target element)
+ $connectionsByTarget = array();
+ foreach ($allConnections as $conn) {
+ if (!isset($connectionsByTarget[$conn->fk_target])) {
+ $connectionsByTarget[$conn->fk_target] = array();
+ }
+ $connectionsByTarget[$conn->fk_target][] = $conn;
+ }
+
+ if (!empty($tree)) {
+ print '
';
+ printTree($tree, $id, $systemId, $permissiontoadd, $permissiontodelete, $langs, 0, $typeFieldsMap, $connectionsByTarget);
+ print '
';
+ } else {
+ print '
'.$langs->trans('NoInstallations').'
';
+ }
}
}
}
@@ -1146,7 +1206,7 @@ function printTree($nodes, $contactid, $systemId, $canEdit, $canDelete, $langs,
$mainText = $conn->label ? $conn->label : $cableInfo;
$badgeText = $conn->label ? $cableInfo : '';
- $connEditUrl = dol_buildpath('/kundenkarte/anlage_connection.php', 1).'?id='.$conn->id.'&socid='.$node->fk_soc.'&system_id='.$systemId;
+ $connEditUrl = dol_buildpath('/kundenkarte/anlage_connection.php', 1).'?id='.$conn->id.'&socid='.$node->fk_soc.'&contactid='.$id.'&system_id='.$systemId;
print '
';
print '';
if ($mainText) {
@@ -1394,7 +1454,7 @@ function printTreeWithCableLines($nodes, $contactid, $systemId, $canEdit, $canDe
$mainText = $conn->label ? $conn->label : $cableInfo;
$badgeText = $conn->label ? $cableInfo : '';
- $connEditUrl = dol_buildpath('/kundenkarte/anlage_connection.php', 1).'?id='.$conn->id.'&socid='.$node->fk_soc.'&system_id='.$systemId;
+ $connEditUrl = dol_buildpath('/kundenkarte/anlage_connection.php', 1).'?id='.$conn->id.'&socid='.$node->fk_soc.'&contactid='.$id.'&system_id='.$systemId;
print '';
// Draw vertical line columns (for cables passing through)