tw5-graph 1.7.1

package/plugins/graph/macros/edges.typed.tid

@@ -0,0 +1,54 @@
+\widget $edges.typed($editable:no)
+\whitespace trim
+<$parameters
+	$$functions={{{ [<functionsFilter>!is[blank]] ~"[all[]]" }}}
+	$$fields={{{ [<fieldsFilter>!is[blank]] ~"[all[]]" }}}
+	$$tiddler=<<currentTiddler>> >
+
+<!-- First create edges for field types -->
+
+<$list variable=fieldName filter="+[subfilter{$:/plugins/flibbles/graph/subfilters##edgetypes.fields}subfilter<$fields>]">
+
+<$let
+	dataTiddler=`$:/config/flibbles/graph/edges/fields/$(fieldName)$` >
+
+<$properties $for=edges
+	$tiddler=<<dataTiddler>>
+	delete={{{ [<$editable>!match[no]then[<$action-removetyped $tiddler=<<fromTiddler>> $field=<<fieldName>> $value=<<toTiddler>> />]] }}} >
+
+
+<$list variable=toTiddler counter=index filter="[<$tiddler>] :map:flat[gettyped<fieldName>] +[!is[blank]]">
+
+<$vars id=`$:/edge/fields/$($tiddler)$
+$(fieldName)$-$(index)$`>
+
+<$slot $name=ts-raw>
+
+<$edge $from=<<$tiddler>> $id=<<id>> />
+
+</$slot></$vars></$list></$properties></$let></$list>
+
+<!-- Now create edges for function types -->
+
+<$list variable=functionName filter="[subfilter{$:/plugins/flibbles/graph/subfilters##edgetypes.functions}subfilter<$functions>]">
+
+<$let
+	dataTiddler=`$:/config/flibbles/graph/edges/functions/$(functionName)$`
+	function={{{ [<dataTiddler>get[filter]] }}} >
+
+<$properties $for=edges
+	$tiddler=<<dataTiddler>> >
+
+<$list variable=toTiddler counter=index filter="[<$tiddler>] :map:flat[subfilter<function>] +[!is[blank]]">
+
+<$vars id=`$:/edge/functions/$($tiddler)$
+$(functionName)$-$(index)$`>
+
+<$slot $name=ts-raw>
+
+<$edge $from=<<$tiddler>> $id=<<id>> />
+
+</$slot></$vars></$list></$properties></$let></$list>
+\end
+
+\relink $edges.typed $functions:filter $fields:filter $tiddler:title

package/plugins/graph/macros/graph.view.tid

@@ -0,0 +1,24 @@
+\widget $graph.view($tiddler:"$:/graph/Default", $mode)
+\whitespace trim
+<$parameters
+	$params=viewParams
+	$parseMode=$defaultMode
+	$$template={{{ [<$tiddler>get[template]] ~[[$:/tags/flibbles/graph/Template]tagging[]first[]] }}}
+	$$engine={{{ [<$tiddler>get[engine]] ~[<graphengine>] }}} >
+
+<$vars
+	currentTiddler=<<$tiddler>>
+	graphengine=<<$engine>> >
+
+<$genesis
+	$type="$transclude"
+	$$tiddler=<<$template>>
+	$$fillignore=yes
+	$$mode={{{ [<$mode>!is[blank]else<$defaultMode>] }}}
+	$names="[<viewParams>jsonindexes[]!prefix[$]]"
+	$values="[<viewParams>jsonindexes[]!prefix[$]] :map[<viewParams>jsonget{!!title}]" />
+
+</$vars></$parameters>
+\end
+
+\relink $graph.view $tiddler

package/plugins/graph/macros/node.default.tid

@@ -0,0 +1,9 @@
+\widget $node.default()
+<$wikify name=label
+	mode=inline
+	text={{{ [{!!title}get[caption]else[<$text text={{!!title}} />]] }}} >
+
+  <$node $pos=<<pos>> label=<<label>> color={{!!color}} image={{!!icon}} />
+
+</$wikify>
+\end

package/plugins/graph/macros/nodes.neighbors.tid

@@ -0,0 +1,62 @@
+\widget $nodes.neighbors($filter, $fields:'[all[]]', $functions:'[all[]]', $interedges, $whitelist:'[!is[system]!is[draft]]')
+
+<!-- None of these \procedures are \functions because that mucks with caching. -->
+\procedure filter.cached() [{!!title}] :cache[all[tiddlers]subfilter<$filter>]
+
+<!-- Holy nuts this is getting complicated, but we need to :map:flat twice
+     in order to switch ..currentTiddler and currentTiddler, as the fields
+     and functions will expect it. -->
+\procedure edges.fields.flipped() [<..currentTiddler>] :map:flat[<currentTiddler>gettyped<..currentTiddler>]
+\procedure edges.functions.flipped() [<..currentTiddler>] :map:flat[<currentTiddler>subfilter<..currentTiddler>]
+
+\procedure edges.fields() :cache[subfilter{$:/plugins/flibbles/graph/subfilters##edgetypes.fields}subfilter<$fields>] :map:flat[<..currentTiddler>subfilter<edges.fields.flipped>]
+\procedure edges.functions() :cache[subfilter{$:/plugins/flibbles/graph/subfilters##edgetypes.functions}subfilter<$functions>addprefix[$:/config/flibbles/graph/edges/functions/]get[filter]] :map:flat[<..currentTiddler>subfilter<edges.functions.flipped>]
+
+\procedure neighbors.for() [subfilter<edges.fields>] [subfilter<edges.functions>] +[!is[blank]unique[]]
+\procedure neighbors.cached() [all[]] :cache[subfilter<neighbors.for>]
+
+\procedure incoming.raw() [all[tiddlers]subfilter<$whitelist>!search:title:regexp,casesensitive<regexp>] :filter[subfilter<neighbors.cached>search:title:regexp,casesensitive<regexp>]
+\procedure incoming.cached() :cache[subfilter<incoming.raw>]
+\whitespace trim
+
+<$vars
+	regexp={{{ [subfilter<filter.cached>escaperegexp[]join[|]addprefix[^(?:]addsuffix[)$]] }}}
+	functionsFilter=<<$functions>>
+	fieldsFilter=<<$fields>> >
+
+<!-- incoming neighbors -->
+
+<$list filter=<<incoming.cached>> >
+
+<$slot $name=ts-raw>
+
+<$node.default />
+
+</$slot>
+
+<$edges.typed>
+
+<%if [<$interedges>match[yes]] ~[<toTiddler>search:title:regexp,casesensitive<regexp>] %>
+
+<$edge $id=<<id>> />
+
+<%endif%></$edges.typed></$list>
+
+<!-- outgoing neighbors -->
+
+<$list filter="[subfilter<filter.cached>subfilter<neighbors.cached>subfilter<$whitelist>!search:title:regexp,casesensitive<regexp>] -[subfilter<incoming.cached>]">
+
+<$slot $name=ts-raw>
+
+<$node.default />
+
+</$slot>
+
+<%if [<$interedges>match[yes]] %>
+
+<$edges.typed />
+
+<%endif%></$list>
+\end
+
+\relink $nodes.neighbors $filter:filter $fields:filter $functions:filter $whitelist:filter

package/plugins/graph/macros/nodes.writable.tid

@@ -0,0 +1,37 @@
+\widget $nodes.writable($field, $variable:currentTiddler)
+
+\procedure actionAddnode()
+\whitespace trim
+<$action-modal $tiddler="$:/plugins/flibbles/graph/ui/Modals/SelectTiddler">
+  <% if [<selection>!is[tiddler]] %>
+    <$action-createtiddler $basetitle=<<selection>> />
+  <% endif %>
+  <% if [<$field>!match[]] %>
+    <$action-addtyped $tiddler=<<$tiddler>> $field=<<$field>> $value=<<selection>> />
+  <% endif %>
+  <$transclude $variable=recordPosition title=<<selection>> />
+</$action-modal>
+<$action-sendmessage $message=tm-focus-selector $param="input.graph-select" />
+\end actionAddnode
+
+\whitespace trim
+<$parameters $$tiddler={{!!title}}>
+
+<$properties $for=graph
+	doubleclick=<<actionAddnode>>
+	addNode=<<actionAddnode>>
+	drop="""<$action-addtyped $tiddler=<<$tiddler>> $field=<<$field>> $value=<<dropTiddler>> />"""
+	addEdge="""<$action.addedge/>"""
+/>
+
+<$properties delete="<$action-removetyped $tiddler=<<$tiddler>> $field=<<$field>> $value=<<nodeTiddler>> />">
+
+<$list variable=<<$variable>> filter="[<$tiddler>gettyped<$field>!is[draft]]">
+
+<$slot $name=ts-raw>
+
+<$node.default />
+
+\end
+
+\relink $nodes.writable $field:fieldname $tiddler:title

package/plugins/graph/macros/properties.persistent.tid

@@ -0,0 +1,27 @@
+\widget $properties.persistent($dataTiddler)
+\whitespace trim
+
+\function pos() [<$dataTiddler>getindex{!!title}]
+
+\procedure recordPosition(title)
+\whitespace trim
+<$action-setfield
+  $tiddler=<<$dataTiddler>>
+  $index=<<title>>
+  $value=`$(x)$,$(y)$`/>
+<%if [<$dataTiddler>!prefix[$:/graph/]] %>
+  <$fieldmangler tiddler=<<$dataTiddler>> >
+    <$action-sendmessage $message=tm-add-tag $param="$:/tags/flibbles/graph/TiddlerData" />
+  </$fieldmangler>
+<%endif%>
+\end recordPosition
+
+<$properties
+  free="<$transclude $variable=recordPosition title=<<nodeTiddler>> />"
+  delete="<$action-setfield $tiddler=<<$dataTiddler>> $index=<<nodeTiddler>>/>">
+
+<$slot $name=ts-raw />
+
+\end
+
+\relink $properties.persistent $dataTiddler:title

package/plugins/graph/macros/properties.popup.tid

@@ -0,0 +1,76 @@
+\widget $properties.popup($enabled:yes $ms:600, $width, $height:50%, $for:nodes)
+\whitespace trim
+
+<$parameters $state={{{ [<qualify "$:/state/graph/tooltip">addsuffix[-]addsuffix<$for>] }}} >
+
+<$let state=<<$state>>
+	delayState=`$(state)$-delay`
+	blurringState=`$(state)$-interrupt`
+	draggingState=`$(state)$-dragging`
+	$msLinger=0>
+
+<$properties $for={{{ [<$enabled>match[yes]then<$for>] }}}
+  hover="""\whitespace trim
+    <%if [<draggingState>] [<state>] +[is[tiddler]count[]match[0]] %>
+      <$action-delay $state=<<delayState>> $ms=<<$ms>> >
+        <$action-with $offset="mouse" $canvas=canvas>
+          <$vars
+              lr={{{ [<mouse-x>multiply[2]compare:number:gt<canvas-width>then[right]else[left]] }}}
+              tb={{{ [<mouse-y>multiply[2]compare:number:gt<canvas-height>then[bottom]else[top]] }}} >
+            <$action-popup $state=<<$state>> $coords="(0,0,0,0)"/>
+            <$genesis $type=$action-setfield $$tiddler=<<$state>>
+              $names="[<$for>subfilter{$:/plugins/flibbles/graph/subfilters##actioncontext}addprefix[context.]]"
+              $values="[<$for>subfilter{$:/plugins/flibbles/graph/subfilters##actioncontext}getvariable[]]"
+              x={{{ [<lr>match[left]then<mouse-x>] ~[<canvas-width>subtract<mouse-x>] }}}
+              y={{{ [<tb>match[top]then<mouse-y>] ~[<canvas-height>subtract<mouse-y>] }}}
+              lr=<<lr>>
+              tb=<<tb>> />
+          </$vars>
+        </$action-pointer>
+      </$action-delay>
+    <%endif%>
+    <$action-deletetiddler $tiddler=<<blurringState>> />"""
+  blur="""\whitespace trim
+    <$action-delay $state=<<blurringState>> $ms=<<$msLinger>> >
+      <$action-deletetiddler $tiddler=<<delayState>> />
+      <$action-popup $state=<<state>> />"""
+  drag="""\whitespace trim
+    <$action-deletetiddler $tiddler=<<delayState>> />
+    <$action-popup $state=<<state>> />
+    <$action-setfield $tiddler=<<draggingState>> text=dragging />"""
+  free='<$action-deletetiddler $tiddler=<<draggingState>> />' >
+
+<$slot $name="ts-raw" />
+
+</$properties>
+
+<$vars
+  x={{{ [<$state>get[x]] }}}
+  y={{{ [<$state>get[y]] }}}
+  lr={{{ [<$state>get[lr]] }}}
+  tb={{{ [<$state>get[tb]] }}}
+  width={{{ [<$width>!is[blank]addprefix[max-width:]addsuffix[;]] }}} >
+
+<!-- We aren't using the popup type because we need to be more dynamic about placing the popup in different directions. The text must be a coord because of $action-popup, but we don't use it. -->
+
+<%if [<$enabled>match[yes]] %>
+
+<$reveal
+  type=match
+  text="(0,0,0,0)"
+  state=<<$state>>
+  positionAllowNegative=yes
+  class="graph-popup tc-popup tc-popup-keep"
+  style=`$(width)$max-height:$($height)$;$(lr)$:$(x)$px;$(tb)$:$(y)$px;`>
+
+<$genesis $type=$vars
+  $names="[<$state>fields[]removeprefix[context.]]"
+  $values="[<$state>fields[]prefix[context.]] :map[<$state>get{!!title}]" >
+
+<$slot $name=tooltip>
+
+<$transclude $tiddler=<<nodeTiddler>> />
+
+\end
+
+\relink $properties.popup $state:title

package/plugins/graph/macros/properties.river.tid

@@ -0,0 +1,27 @@
+\widget $properties.river()
+\parameters ($state: "$:/state/flibbles/graph/river")
+\whitespace trim
+
+<%if [<graph-sidebar>!match[yes]] %>
+
+<$qualify name=state title=<<$state>> >
+
+<$properties $for=graph
+	blur="<$action-deletetiddler $tiddler=<<state>> />"
+	focus="<$action-setfield $tiddler=<<state>> text=focused />"
+	zoom={{{ [<state>get[text]match[focused]then[yes]else[no]] }}} />
+
+<$slot $name="ts-raw" />
+
+<$properties $for=graph navigation={{{ [<state>get[text]match[focused]then[]else[no]] }}} />
+
+</$qualify><%else%>
+
+<$properties $for=graph zoom=yes />
+
+<$slot $name="ts-raw" />
+
+<%endif%>
+\end
+
+\relink $properties.river $state:title

package/plugins/graph/macros/properties.settings.tid

@@ -0,0 +1,54 @@
+\widget $properties.settings()
+\whitespace trim
+
+<$properties.popup
+  $enabled={{!!popup}}
+  $ms={{{ [{!!title}get[popup.ms]else[600]] }}}
+  $width={{{ [{!!title}get[popup.width]else[300px]] }}}
+  $height={{{ [{!!title}get[popup.height]else[200px]] }}} >
+
+<$fill $name=tooltip>
+
+<$let
+  currentGraph=<<currentTiddler>>
+  currentTiddler=<<nodeTiddler>> >
+
+<%if [<currentGraph>has[popup.template]] %>
+
+<$transclude $tiddler=<<currentGraph>> $field="popup.template" />
+
+<%else%>
+
+{{}}
+<%endif%></$let></$fill>
+
+<$properties.river>
+
+<$properties $tiddler={{!!title}} $field="graph.edges" $for=edges >
+
+<$properties $tiddler={{!!title}} $field="graph.nodes" $for=nodes >
+
+<$properties.stack>
+
+<$let
+  fieldsFilter={{{ [{!!edges.fields}!is[blank]] ~"[all[]]" }}}
+  functionsFilter={{{ [{!!edges.functions}!is[blank]] ~"[all[]]" }}}>
+
+<$slot $name="ts-raw" $depth=4 />
+
+<%if [{!!neighbors.incoming}] =[{!!neighbors.outgoing}] +[match[1]count[]match[2]] %>
+
+<$properties $tiddler="$:/config/flibbles/graph/nodes/neighbors/1" >
+ 
+<$nodes.neighbors
+  $filter={{!!filter}}
+  $functions=<<functionsFilter>>
+  $fields=<<fieldsFilter>>
+  $interedges={{!!neighbors.interedges}}
+  $whitelist={{{ [{!!title}get[neighbors.whitelist]] ~"[!is[system]]" }}} />
+
+</$properties><%endif%></$let></$properties.stack></$properties></$properties>
+<$properties $tiddler={{!!title}} $field="graph.graph" $for=graph />
+
+</$properties.river></$properties.popup>
+\end

package/plugins/graph/macros/properties.stack.tid

@@ -0,0 +1,17 @@
+\widget $properties.stack()
+\procedure $properties.stack.recurse(zth)
+\procedure node.stack() [list[$:/config/flibbles/graph/nodes/stack]] =[all[shadows+tiddlers]prefix[$:/config/flibbles/graph/nodes/stack/]sort[]] +[unique[]is[tiddler]]
+\whitespace trim
+<%if :cache[subfilter<node.stack>] +[zth<zth>] %>
+  <$properties $filter={{{ [<condition>get[filter]] }}} $tiddler=<<condition>> >
+    <$transclude $variable=$properties.stack.recurse $fillignore=yes zth={{{ [<zth>add[1]] }}} />
+  </$properties>
+<%else%>
+  <$slot $name=ts-raw />
+<%endif%>
+\end $properties.stack.recurse
+\whitespace trim
+
+<$transclude $variable=$properties.stack.recurse zth=0 $fillignore=yes />
+
+\end

package/plugins/graph/macros/tiddlywiki.files

@@ -0,0 +1,17 @@
+{
+	"directories": [
+		{
+			"path": ".",
+			"filesRegExp": "^.*\\.tid$",
+			"isTiddlerFile": false,
+			"fields": {
+				"title": {
+					"source": "basename",
+					"prefix": "$:/plugins/flibbles/graph/macros/"
+				},
+				"tags": "$:/tags/Global",
+				"code-body": "yes"
+			}
+		}
+	]
+}

package/plugins/graph/nodes/neighbors/1.tid

@@ -0,0 +1,8 @@
+title: $:/config/flibbles/graph/nodes/neighbors/1
+caption: All
+description: Applies to the first generation of neighbors, hence why it's called "1". But currently only one is allowed, which is why the caption is "All".
+type: application/json
+
+{
+    "color": "muted-foreground"
+}

package/plugins/graph/plugin.info

@@ -0,0 +1,14 @@
+{
+	"name": "Graph",
+	"title": "$:/plugins/flibbles/graph",
+	"description": "Lightweight and programmable graphing for Tiddlywiki",
+	"author": "Flibbles",
+	"version": "1.7.1",
+	"stability": "STABILITY_2_STABLE",
+	"core-version": ">=5.3.7",
+	"source": "https://github.com/flibbles/tw5-graph",
+	"demo": "http://flibbles.github.io/tw5-graph/",
+	"list": "readme settings",
+	"dependents": "",
+	"plugin-type": "plugin"
+}

package/plugins/graph/presettypes/edges/fields.tid

@@ -0,0 +1,18 @@
+title: $:/plugins/flibbles/graph/presettypes/edges/fields
+
+\procedure typeSelector()
+\whitespace trim
+<$select tiddler=`$:/config/flibbles/relink/fields/$(fieldName)$` default=list>
+  <$list filter="[[$:/plugins/flibbles/relink]is[tiddler]then[relinkfieldtype]else[fieldtype]modules[]moduleproperty[name]]">
+    <option>
+      <$text text={{!!title}} />
+    </option>
+  </$list>
+</$select>
+\end
+
+"Fields" presets define the edge properties for edges corresponding to tiddler fields. These types of edges can be easily added to a node using the <<.link EdgesAllWidget>> widget, or the more inclusive `$edges.typed` widget, which encompasses all other types of preset edge types.
+
+<$vars fieldName={{{ [<currentTiddler>removeprefix[$:/config/flibbles/graph/edges/fields/]] }}}>
+
+Field type: <<typeSelector>>

package/plugins/graph/presettypes/edges/functions.tid

@@ -0,0 +1,5 @@
+title: $:/plugins/flibbles/graph/presettypes/edges/functions
+
+"Function" edges define properties for edges generated from input nodes //individually// into a filter, and then creating an edge from that node to each of the filter's output.
+
+Filter: <$edit-text field=filter />

package/plugins/graph/presettypes/nodes/neighbors.tid

@@ -0,0 +1,4 @@
+title: $:/plugins/flibbles/graph/presettypes/nodes/neighbors
+fixed: yes
+
+"neighbor" properties are applied to neighbors exposed in a Graph Tiddler with Neighbors enabled. Currently only one layer of neighbors are allowed.

package/plugins/graph/presettypes/nodes/stack.tid

@@ -0,0 +1,6 @@
+title: $:/plugins/flibbles/graph/presettypes/nodes/stack
+orderable: yes
+
+"stack" nodes define the node properties that can be applied as a stack to contained nodes, such as nodes contained within `$properties.stack`. For each node, the stack of node properties are applied one after another, each depending on if that node matches any given stack property's filter.
+
+Filter: <$edit-text field=filter />

package/plugins/graph/propertytypes/actions.js

@@ -0,0 +1,15 @@
+/*\
+
+Defines behavior to be taken in the event that particular action is called.
+
+\*/
+
+"use strict";
+
+exports.name = "actions";
+
+exports.type = "wikitext";
+
+exports.toProperty = function(info, value) {
+	return value? true: null;
+};

package/plugins/graph/propertytypes/boolean.js

@@ -0,0 +1,23 @@
+/*\
+
+Defines behavior for boolean types in graph engine properties.
+
+\*/
+
+"use strict";
+
+exports.name = "boolean";
+
+var falses = {
+	no: true,
+	"false": true,
+	"0": true,
+	n: true,
+	f: true,
+	'': true,
+	' ': true
+};
+
+exports.toProperty = function(info, value) {
+	return !falses[value.toLowerCase()];
+};

package/plugins/graph/propertytypes/color.js

@@ -0,0 +1,61 @@
+/*\
+
+Defines colors, which can derive from palette colors.
+
+\*/
+
+"use strict";
+
+var utils = require("../utils.js");
+
+exports.name = "color";
+
+exports.toProperty = function(info, value, options) {
+	// If it starts with #, we don't have to bother trying to find palette
+	// colors. This is 99% of the time, so worth the optimization.
+	if (typeof value !== "string" || value.charAt(0) === "#") {
+		return value || null;
+	}
+	var widget = options.widget;
+	widget.colorWidgets = widget.colorWidgets || Object.create(null);
+	if (!widget.colorWidgets[value]) {
+		widget.colorWidgets[value] = widget.wiki.makeWidget({
+			tree: [{
+				type: "transclude",
+				attributes: {
+					"$variable": {type: "string", value: "colour"},
+					0: {type: "string", value: value}}
+			}]}, {parentWidget: widget});
+	}
+	var colorWidget = widget.colorWidgets[value];
+	var container = $tw.fakeDocument.createElement("div");
+	colorWidget.render(container, null);
+	var output = container.textContent;
+	if (output) {
+		return output;
+	}
+	// Might be a CSS color;
+	if (colorWidget.cssColor === undefined) {
+		colorWidget.cssColor = isValidCSSColor(value)? value: null;
+	}
+	return colorWidget.cssColor;
+};
+
+exports.refresh = function(info, value, changedTiddlers, widget) {
+	if (value && value.charAt(0) !== "#") {
+		if (widget.colorWidgets
+		&& widget.colorWidgets[value]
+		&& widget.colorWidgets[value].refresh(changedTiddlers)) {
+			return true;
+		}
+	}
+	return false;
+};
+
+function isValidCSSColor(color) {
+	var window = utils.window();
+	var option = new window.Option();
+	var s = option.style;
+	s.color = color;
+	return s.color === color;
+};

package/plugins/graph/propertytypes/enum.js

@@ -0,0 +1,25 @@
+/*\
+
+Defines behavior for enum types in graph engine properties.
+
+\*/
+
+"use strict";
+
+exports.name = "enum";
+
+exports.toProperty = function(info, value) {
+	if (info.multiple) {
+		var values = $tw.utils.parseStringArray(value);
+		if (values.length === 0) {
+			return values;
+		}
+		var filtered = values.filter(v => info.values.indexOf(v) >= 0);
+		if (filtered.length > 0) {
+			return filtered;
+		}
+	} else if (value && info.values.indexOf(value) >= 0) {
+		return value;
+	}
+	return null;
+};

package/plugins/graph/propertytypes/filter.js

@@ -0,0 +1,44 @@
+/*\
+
+Defines behavior for filter types in graph engine properties.
+The property values are strings which are processed as filters.
+The results are passed to the underlying engine as an array.
+
+\*/
+
+"use strict";
+
+exports.name = "filter";
+
+exports.type = "filter";
+
+exports.toProperty = function(info, value, options) {
+	var widget = options.widget;
+	var output = widget.wiki.filterTiddlers(value, widget);
+	widget._graphFilterCache = widget._graphFilterCache || Object.create(null);
+	widget._graphFilterCache[value] = output;
+	return output;
+};
+
+exports.refresh = function(info, value, changedTiddlers, widget) {
+	var output = widget.wiki.filterTiddlers(value, widget);
+	if (!match(output, widget._graphFilterCache[value])) {
+		return true;
+	}
+	return false;
+};
+
+function match(arrayA, arrayB) {
+	if ((!arrayA || !arrayB) && (arrayA !== arrayB)) {
+		return false;
+	}
+	if (arrayA.length !== arrayB.length) {
+		return false;
+	}
+	for (var i = 0; i < arrayA.length; i++) {
+		if (arrayA[i] !== arrayB[i]) {
+			return false;
+		}
+	}
+	return true;
+};