tw5-vis-network 10.5.5

package/plugins/vis-network/properties/image.js

@@ -0,0 +1,35 @@
+/*
+
+Manages images in nodes.
+
+*/
+
+"use strict";
+
+exports.name = "image";
+
+exports.properties = {
+	nodes: {
+		shape: {type: "enum", values: ["box", "circle", /*"circularImage",*/ "diamond", "database", "dot", "ellipse", "hexagon", /*"icon",*/ /*"image",*/ "square", "star", "text", "triangle", "triangleDown"]},
+		image: {type: "image"},
+			circular: {type: "boolean", parent: "image", default: false},
+	}
+};
+
+exports.process = function(objects, changes) {
+	if (changes.nodes) {
+		for (var id in changes.nodes) {
+			var node = changes.nodes[id];
+			if (node) {
+				if (node.image) {
+					node.shape = node.circular? "circularImage": "image";
+					node.circular = undefined;
+				} else {
+					if (node.shape === "image" || node.shape === "circularImage") {
+						node.shape = undefined;
+					}
+				}
+			}
+		}
+	}
+};

package/plugins/vis-network/properties/interaction.js

@@ -0,0 +1,48 @@
+/*
+
+Manages all the structure for graph interaction.
+
+*/
+
+"use strict";
+
+exports.name = "interaction";
+
+exports.properties = {
+	graph: {
+		navigation: {type: "boolean"},
+		zoom: {type: "boolean", default: true},
+		zoomSpeed: {type: "number", min: 0, max: 10, increment: 0.1, default: 1},
+	}
+};
+
+exports.process = function(objects, changes) {
+	var graph = changes.graph;
+	if (graph) {
+		if (graph.zoom !== undefined) {
+			graph.interaction = graph.interaction || {};
+			graph.interaction.zoomView = graph.zoom;
+			graph.zoom = undefined;
+		} else if (objects.graph && objects.graph.interaction && objects.graph.interaction.zoomView == false) {
+			// It was set, and now we're unsetting it back to true
+			graph.interaction = {zoomView: true};
+		}
+		if (graph.navigation !== undefined) {
+			graph.interaction = graph.interaction || {};
+			graph.interaction.navigationButtons = graph.navigation;
+			graph.navigation = undefined;
+		} else if (objects.graph && objects.graph.interaction && objects.graph.interaction.navigationButtons == true) {
+			// It was set, and now we're unsetting it back to true
+			graph.interaction = graph.interaction || {};
+			graph.interaction.navigationButtons = false;
+		}
+		if (graph.zoomSpeed !== undefined) {
+			graph.interaction = graph.interaction || {};
+			graph.interaction.zoomSpeed = graph.zoomSpeed;
+			graph.zoomSpeed = undefined;
+		} else if (objects.graph && objects.graph.interaction && objects.graph.interaction.zoomSpeed !== undefined) {
+			graph.interaction = graph.interaction || {};
+			graph.interaction.zoomSpeed = 1;
+		}
+	}
+};

package/plugins/vis-network/properties/layout.js

@@ -0,0 +1,55 @@
+/*
+
+Manages all the hierarchy for graph manipulation.
+
+*/
+
+"use strict";
+
+var map = {
+	hierarchyDirection: "direction",
+	hierarchyNodeSpacing: "nodeSpacing",
+	hierarchyParentCentralization: "parentCentralization",
+	hierarchyShakeTowards: "shakeTowards",
+	hierarchySortMethod: "sortMethod",
+};
+
+exports.name = "layout";
+
+exports.properties = {
+	graph: {
+		hierarchy: {type: "boolean", default: false},
+		hierarchyDirection: {type: "enum", parent: "hierarchy", default: "UD", values: ["UD", "DU", "LR", "RL"]},
+		hierarchyNodeSpacing: {type: "number", parent: "hierarchy", default: 100, min: 0, max:200},
+		//hierarchyShakeTowards: {type: "enum", default: "leaves", values: ["leaves", "roots"]},
+		//hierarchyParentCentralization: {type: "boolean", default: true},
+		//hierarchySortMethod: {type: "enum", default: "hubsize", values: ["hubsize", "directed"]},
+	}
+};
+
+exports.process = function(objects, changes) {
+	var graph = changes.graph;
+	if (graph) {
+		if (graph.hierarchy !== undefined) {
+			graph.layout = {hierarchical: graph.hierarchy};
+			graph.hierarchy = undefined;
+		} else if (objects.graph && objects.graph.layout && objects.graph.layout.hierarchical) {
+			// It was already there. It must be removed.
+			graph.layout = {hierarchical: false};
+		}
+		var layout = graph.layout;
+		for (var property in graph) {
+			if (map[property]) {
+				if (layout && layout.hierarchical !== false) {
+					if (typeof layout.hierarchical !== "object") {
+						layout.hierarchical = {};
+					}
+					layout.hierarchical[map[property]] = graph[property];
+				}
+				// One way or another, we must always remove all
+				// single-depth hierarchy settings
+				graph[property] = undefined;
+			}
+		}
+	}
+};

package/plugins/vis-network/properties/manipulation.js

@@ -0,0 +1,181 @@
+/*
+
+Manages all the structure for graph manipulation.
+
+*/
+
+"use strict";
+
+exports.name = "manipulation";
+
+exports.properties = {
+	graph: {
+		hideControls: {type: "boolean", default: false, description: "Hide node and edge manipulation controls by default"},
+		addNode: {type: "actions", variables: ["x", "y"]},
+		addEdge: {type: "actions", variables: ["fromTiddler", "toTiddler"]},
+	},
+	nodes: {
+		delete: {type: "actions", variables: []},
+		edit: {type: "actions", variables: []},
+	},
+	edges: {
+		delete: {type: "actions"},
+		//edit: {type: "actions", variables: []},
+	}
+};
+
+exports.process = function(objects, changes) {
+	var self = this,
+		old = objects.graph && objects.graph.manipulation,
+		wasUnset = !old;
+	if (wasUnset) {
+		old = defaults();
+	}
+	var settings = $tw.utils.extend({}, old);
+	if (!this.manipulation) {
+		// We keep track of how many of these we have so we can know when to
+		// keep these behaviors.
+		this.manipulation = {
+			deleteEdge: 0,
+			deleteNode: 0,
+			editEdge: 0,
+			editNode: 0,
+			fold: false
+		}
+	}
+	if (changes.graph) {
+		if (changes.graph.addNode) {
+			settings.addNode = function(nodeData, callback) {
+				self.onevent({
+					type: "addNode",
+					objectType: "graph"
+				},{
+					x: round(nodeData.x),
+					y: round(nodeData.y)});
+			}
+		} else {
+			settings.addNode = false;
+		}
+		if (changes.graph.addEdge) {
+			settings.addEdge = function(edgeData, callback) {
+				self.onevent({
+					type: "addEdge",
+					objectType: "graph"
+				},{
+					fromTiddler: edgeData.from,
+					toTiddler: edgeData.to});
+			}
+		} else {
+			settings.addEdge = false;
+		}
+		// We set it undefined, whatever it is, because it'll need to be purged
+		// before being passed to vis. It doesn't like unknown properties.
+		changes.graph.addNode = undefined;
+		changes.graph.addEdge = undefined;
+	}
+	// Get an accurate count of object-specific manipulations
+	if (changes.edges) {
+		for (var id in changes.edges) {
+			this.manipulation.deleteEdge += difference(objects.edges, changes.edges, id, "delete");
+		}
+	}
+	var oldEditCount = this.manipulation.editNode;
+	if (changes.nodes) {
+		for (var id in changes.nodes) {
+			this.manipulation.deleteNode += difference(objects.nodes, changes.nodes, id, "delete");
+			this.manipulation.editNode += difference(objects.nodes, changes.nodes, id, "edit");
+		}
+	}
+	// If we have a positive number of object manipulations, add them now
+	if (this.manipulation.deleteNode > 0) {
+		settings.deleteNode = function(selected, callback) {
+			self.onevent({
+				type: "delete",
+				objectType: "nodes",
+				id: selected.nodes[0]}, {});
+			callback({nodes: [], edges: []});
+		}
+	} else {
+		settings.deleteNode = false;
+	}
+	if (this.manipulation.editNode > 0) {
+		settings.editNode = function(node, callback) {
+			self.onevent({
+				type: "edit",
+				objectType: "nodes",
+				id: node.id}, {});
+			callback(null);
+		}
+	} else {
+		// Look at this. vis-network treats editNode differently.
+		// They don't take a boolean to turn it off, but they forgot that
+		// that means it can't be turned off at all without logging an
+		// error. YAY. We minimize how often we explicitly set editNode
+		// to false, to minimize this error.
+		settings.editNode = (oldEditCount > 0)? false: undefined;
+	}
+	if (this.manipulation.deleteEdge > 0) {
+		settings.deleteEdge = function(selected, callback) {
+			self.onevent({
+				type: "delete",
+				objectType: "edges",
+				id: selected.edges[0]}, {});
+			callback({nodes: [], edges: []});
+		}
+	} else {
+		settings.deleteEdge = false;
+	}
+	// We check if we manually set our manipulation folding
+	var fold = false;
+	if (changes.graph) {
+		fold = !!changes.graph.hideControls;
+		changes.graph.hideControls = undefined;
+	} else {
+		fold = this.manipulation.fold;
+	}
+	// Now we install our manipulations if we have any.
+	if (changed(old, settings) || fold !== this.manipulation.fold) {
+		changes.graph = changes.graph || objects.graph || Object.create(null);
+		this.manipulation.fold = fold;
+		if (changed(settings, defaults())) {
+			settings.initiallyActive = !fold;
+			changes.graph.manipulation = settings;
+		} else {
+			changes.graph.manipulation = false;
+		}
+	} else if (changes.graph && !wasUnset) {
+		// If we're updating graph settings, but not manipulation,
+		// we must preserve the old manipulation settings.
+		changes.graph.manipulation = old;
+	}
+};
+
+function defaults() {
+	return {
+		addEdge: false,
+		addNode: false,
+		editEdge: false,
+		editNode: undefined,
+		deleteEdge: false,
+		deleteNode: false
+	};
+};
+
+function changed(oldManipulate, newManipulate) {
+	for (var action in newManipulate) {
+		if (!newManipulate[action] !== !oldManipulate[action]) {
+			return true;
+		}
+	}
+	return false;
+};
+
+function difference(oldObjects, newObjects, id, action) {
+	var oldObject = (oldObjects && oldObjects[id]) || {};
+	var newObject = (newObjects && newObjects[id]) || {};
+	return (newObject[action] || 0) - (oldObject[action] || 0);
+};
+
+function round(number) {
+	return Math.round(number * 10) / 10;
+};

package/plugins/vis-network/properties/nodes.js

@@ -0,0 +1,42 @@
+/*
+
+Miscellaneous node properties that don't need special handling.
+
+*/
+
+"use strict";
+
+exports.names = "nodes";
+
+exports.properties = {
+	nodes: {
+		borderWidth: {type: "number", min: 0, default: 1, increment: 0.1},
+		label: {type: "string"},
+		fixed: {type: "boolean", default: false},
+		size: {type: "number", min: 0, default: 25},
+		minWidth: {type: "number", min: 1, max: 500,
+			description: "Minimum width of labels. Affects the size of nodes when labels are contained within"},
+		maxWidth: {type: "number", min: 1, max: 500,
+			description: "Maximum allowed width of labels. Affects the size of nodes when labels are contained within."}
+	},
+};
+
+exports.process = function(objects, changes) {
+	if (changes.nodes) {
+		var oldNodes = (objects && objects.nodes) || {};
+		for (var id in changes.nodes) {
+			var node = changes.nodes[id];
+			if (node) {
+				if (node.minWidth !== undefined
+				|| node.maxWidth !== undefined) {
+					node.widthConstraint = {
+						minimum: node.minWidth,
+						maximum: node.maxWidth
+					};
+					node.minWidth = undefined;
+					node.maxWidth = undefined;
+				}
+			}
+		}
+	}
+};

package/plugins/vis-network/properties/physics.js

@@ -0,0 +1,110 @@
+/*
+
+Manages all the physics for the graph object.
+
+*/
+
+"use strict";
+
+var map = {
+	maxVelocity: "maxVelocity",
+};
+
+var physics = {
+	barnesHut: {
+		theta: 0.5,
+		gravitationalConstant: -2000,
+		centralGravity: 0.3,
+		springLength: 95,
+		springConstant: 0.04,
+		damping: 0.09,
+		avoidOverlap: 0
+	},
+	forceAtlas2Based: {
+		theta: 0.5,
+		gravitationalConstant: -50,
+		centralGravity: 0.01,
+		springConstant: 0.08,
+		springLength: 100,
+		damping: 0.4,
+		avoidOverlap: 0
+	}
+};
+
+//var solver = "barnesHut";
+var solver = "forceAtlas2Based";
+
+exports.name = "physics";
+
+exports.properties = {
+	graph: {
+		physics: {type: "boolean", default: true},
+		centralGravity: {type: "number", parent: "physics",
+			min: 0, max: 1, increment: 0.1, default: 0.3},
+		damping: {type: "number", parent: "physics",
+			min: 0, max: 1, increment: 0.01, default: 0.09},
+		gravitationalConstant: {type: "number", parent: "physics",
+			min: -2000, max: 0, increment: 10, default: -2000},
+		springConstant: {type: "number", parent: "physics",
+			min: 0, max: 0.2, increment: 0.01, default: 0.04},
+		springLength: {type: "number", parent: "physics",
+			min: 0, max: 200, increment: 10, default: 95},
+		maxVelocity: {type: "number", parent: "physics",
+			min: 1, default: 50, max: 100},
+	},
+	nodes: {
+		physics: {type: "boolean", default: true},
+	},
+	edges: {
+		physics: {type: "boolean", default: true},
+	}
+};
+
+exports.process = function(objects, changes) {
+	var graph = changes.graph;
+	var enabled = true;
+	if (graph) {
+		if (graph.physics !== undefined) {
+			if (typeof graph.physics === "boolean") {
+				// The only reason this wouldn't happen is because our graph
+				// settings got recreated by "manipulation", and thus we have
+				// an actually fully formed physics object.
+				graph.physics = freshSettings({enabled: graph.physics});
+			}
+			enabled = graph.physics.enabled;
+		} else {
+			if (objects.graph && objects.graph.physics) {
+				// It was specified at some point. We must continued
+				// to specify it, even if only to set the default.
+				graph.physics = freshSettings({enabled: true});
+			}
+			enabled = true;
+		}
+		for (var property in map) {
+			if (graph[property] !== undefined) {
+				if (enabled) {
+					graph.physics = graph.physics || freshSettings();
+					graph.physics[map[property]] = graph[property];
+				}
+				graph[property] = undefined;
+			}
+		}
+		var solverSettings = physics[solver];
+		for (var property in solverSettings) {
+			if (graph[property] !== undefined) {
+				if (enabled) {
+					graph.physics = graph.physics || freshSettings();
+					graph.physics[solver][property] = graph[property];
+				}
+				graph[property] = undefined;
+			}
+		}
+	}
+};
+
+function freshSettings(initial) {
+	initial = initial || {};
+	initial[solver] = Object.assign({}, physics[solver]);
+	initial.solver = solver;
+	return initial;
+};

package/plugins/vis-network/properties/position.js

@@ -0,0 +1,60 @@
+/*
+
+Manages all the positioning for nodes in graph manipulation.
+
+*/
+
+"use strict";
+
+exports.name = "position";
+
+exports.properties = {
+	nodes: {
+		x: {type: "number"},
+		y: {type: "number"},
+	}
+};
+
+exports.process = function(objects, changes) {
+	if (!this.position) {
+		// We use this to store all positions that were given to us by TW5
+		this.position = Object.create(null);
+	}
+	if (changes.nodes) {
+		for (var id in changes.nodes) {
+			var node = changes.nodes[id];
+			if (node) {
+				if (node.x !== undefined || node.y !== undefined) {
+					var posKey = node.x + "," + node.y;
+					if (this.position[id] === posKey) {
+						// This isn't a new position
+						this.position[id] = posKey;
+						var nodePosition = this.vis.getPosition(id);
+						node.x = nodePosition.x;
+						node.y = nodePosition.y;
+					} else {
+						this.position[id] = posKey;
+					}
+				} else {
+					// Node does not specify a location.
+					// If one had existed, we should preserve its existing loc
+					if (this.position[id] !== undefined) {
+						var nodePosition = this.vis.getPosition(id);
+						node.x = nodePosition.x;
+						node.y = nodePosition.y;
+						// We forget the old set location.
+						// It's "free-floating" now
+						// In the future, we will always record SOME position, even if it's
+						// just what Vis already thinks it to be.
+						// Otherwise we can suffer some nasty recursion exceptions of out Vis.
+						this.position[id] = null;
+					}
+				}
+			} else if (this.position[id] !== undefined) {
+				// The node is being removed. Forget its initial position.
+				// Or that we ever positioned it at all (null).
+				this.position[id] = undefined;
+			}
+		}
+	}
+};

package/plugins/vis-network/properties/tiddlywiki.files

@@ -0,0 +1,17 @@
+{
+	"directories": [
+		{
+			"path": ".",
+			"filesRegExp": "^.*\\.js$",
+			"isTiddlerFile": true,
+			"fields": {
+				"title": {
+					"source": "filename",
+					"prefix": "$:/plugins/flibbles/vis-network/properties/"
+				},
+				"module-type": "vis-property",
+				"type": "application/javascript"
+			}
+		}
+	]
+}

package/plugins/vis-network/readme.tid

@@ -0,0 +1,8 @@
+title: $:/plugins/flibbles/vis-network/readme
+
+\rules except wikilink
+! tw5-vis-network
+
+A tiddlywiki plugin for the [[vis-network library|https://visjs.github.io/vis-network/docs/network/]].
+
+Current vis-network version: v9.1.2

package/plugins/vis-network/vis.js

@@ -0,0 +1,59 @@
+/*\
+title: $:/plugins/flibbles/vis-network/vis.js
+type: application/javascript
+module-type: library
+
+*** TO AVOID STRANGE LIB ERRORS FROM BUBBLING UP *****************
+\*/
+
+"use strict";
+
+if($tw.boot.tasks.trapErrors) {
+
+  var defaultHandler = window.onerror;
+  window.onerror = function(errorMsg, url, lineNumber) {
+    
+    if(errorMsg.indexOf("NS_ERROR_NOT_AVAILABLE") !== -1
+       && url == "$:/plugins/flibbles/vis-network/vis-network.min.js") {
+         
+      var text = "Strange firefox related vis.js error (see #125)";
+      console.error(text, arguments);
+      
+    } else if(errorMsg.indexOf("Permission denied to access property") !== -1) {
+      
+      var text = "Strange firefox related vis.js error (see #163)";
+      console.error(text, arguments);
+      
+    } else if(errorMsg.indexOf("ResizeObserver loop") !== -1) {
+      // Issue appears sporatically. Hard to replicate. Site here indicates
+      // these errors can be safely ignored.
+      // https://stackoverflow.com/questions/49384120/resizeobserver-loop-limit-exceeded/50387233#50387233
+      // variations of this harmless error:
+      //   ResizeObserver loop limit exceeded
+      //   ResizeObserver loop completed with undelivered notifications
+      console.error(errorMsg, arguments);
+    } else if(defaultHandler) {
+      
+      defaultHandler.apply(this, arguments);
+      
+    }
+    
+  }
+  
+}
+
+if ($tw.browser) {
+
+  module.exports = require("$:/plugins/flibbles/vis-network/vis-network.min.js");
+
+  if (CanvasRenderingContext2D.prototype.circle === undefined) {
+
+    // For some reason, vis-network thinks this method exists. It don't.
+    // We've got to add it ourselves if it's not there.
+    CanvasRenderingContext2D.prototype.circle = function(x, y, radius) {
+      return this.arc(x, y, radius, 0, 2 * Math.PI);
+    };
+
+  }
+
+}