tiddlywiki 5.1.21 → 5.2.1

package/plugins/tiddlywiki/dynannotate/modules/selection-tracker.js

@@ -0,0 +1,116 @@
+/*\
+title: $:/plugins/tiddlywiki/dynannotate/selection-tracker.js
+type: application/javascript
+module-type: startup
+
+Dyannotate background daemon to track the selection
+
+\*/
+(function(){
+
+/*jslint node: true, browser: true */
+/*global $tw: false */
+"use strict";
+
+// Export name and synchronous status
+exports.name = "dyannotate-startup";
+exports.platforms = ["browser"];
+exports.after = ["render"];
+exports.synchronous = true;
+
+var TextMap = require("$:/plugins/tiddlywiki/dynannotate/textmap.js").TextMap;
+
+exports.startup = function() {
+	$tw.dynannotate = {
+		selectionTracker: new SelectionTracker($tw.wiki,{
+			allowBlankSelectionPopup: true
+		})
+	};
+};
+
+function SelectionTracker(wiki,options) {
+	options = options || {};
+	var self = this;
+	this.wiki = wiki;
+	this.allowBlankSelectionPopup = options.allowBlankSelectionPopup;
+	this.selectionPopupTitle = null;
+	document.addEventListener("selectionchange",function(event) {
+		var selection = document.getSelection();
+		if(selection && (selection.type === "Range" || (self.allowBlankSelectionPopup && !self.selectionPopupTitle))) {
+			// Look for the selection containers for each of the two ends of the selection
+			var anchorContainer = self.findSelectionContainer(selection.anchorNode),
+				focusContainer = self.findSelectionContainer(selection.focusNode);
+			// If either end of the selection then we ignore it
+			if(!!anchorContainer || !!focusContainer) {
+				var selectionRange = selection.getRangeAt(0);
+				// Check for the selection spilling outside the starting container
+				if((anchorContainer !== focusContainer) || (selectionRange.startContainer.nodeType !== Node.TEXT_NODE && selectionRange.endContainer.nodeType !== Node.TEXT_NODE)) {
+					if(self.selectionPopupTitle) {
+						self.wiki.deleteTiddler(self.selectionPopupTitle);
+						self.selectionPopupTitle = null;
+					}
+				} else {
+					self.selectionSaveTitle = anchorContainer.getAttribute("data-annotation-selection-save");
+					self.selectionPrefixSaveTitle = anchorContainer.getAttribute("data-annotation-selection-prefix-save");
+					self.selectionSuffixSaveTitle = anchorContainer.getAttribute("data-annotation-selection-suffix-save");
+					self.selectionPopupTitle = anchorContainer.getAttribute("data-annotation-selection-popup");
+					// The selection is a range so we trigger the popup
+					if(self.selectionPopupTitle) {
+						var selectionRectangle = selectionRange.getBoundingClientRect(),
+							trackingRectangle = anchorContainer.getBoundingClientRect();
+						$tw.popup.triggerPopup({
+							domNode: null,
+							domNodeRect: {
+								left: selectionRectangle.left - trackingRectangle.left,
+								top: selectionRectangle.top - trackingRectangle.top,
+								width: selectionRectangle.width,
+								height: selectionRectangle.height
+							},
+							force: true,
+							floating: true,
+							title: self.selectionPopupTitle,
+							wiki: self.wiki
+						});						
+					}
+					// Write the selection text to the specified tiddler
+					if(self.selectionSaveTitle) {
+						// Note that selection.toString() normalizes whitespace but selection.getRangeAt(0).toString() does not
+						var text = selectionRange.toString();
+						self.wiki.addTiddler(new $tw.Tiddler({title: self.selectionSaveTitle, text: text}));
+						// Build a textmap of the container so that we can find the prefix and suffix
+						var textMap = new TextMap(anchorContainer);
+						// Find the selection start in the text map and hence extract the prefix and suffix
+						var context = textMap.extractContext(selectionRange.startContainer,selectionRange.startOffset,text);
+						// Save the prefix and suffix
+						if(context) {
+							if(self.selectionPrefixSaveTitle) {
+								self.wiki.addTiddler(new $tw.Tiddler({title: self.selectionPrefixSaveTitle, text: context.prefix}));
+							}
+							if(self.selectionSuffixSaveTitle) {
+								self.wiki.addTiddler(new $tw.Tiddler({title: self.selectionSuffixSaveTitle, text: context.suffix}));
+							}
+						}
+					}
+				}
+			}
+		} else {
+			// If the selection is a caret we clear any active popup
+			if(self.selectionPopupTitle) {
+				self.wiki.deleteTiddler(self.selectionPopupTitle);
+				self.selectionPopupTitle = null;
+			}
+		}
+	});
+}
+
+SelectionTracker.prototype.findSelectionContainer = function findSelectionContainer(domNode) {
+	if(domNode && domNode.nodeType === Node.ELEMENT_NODE && domNode.classList.contains("tc-dynannotation-selection-container")) {
+		return domNode;
+	}
+	if(domNode && domNode.parentNode) {
+		return findSelectionContainer(domNode.parentNode);
+	}
+	return null;
+};
+
+})();

package/plugins/tiddlywiki/dynannotate/modules/textmap.js

@@ -0,0 +1,177 @@
+/*\
+title: $:/plugins/tiddlywiki/dynannotate/textmap.js
+type: application/javascript
+module-type: library
+
+Structure for modelling mapping between a string and its representation in the DOM
+
+\*/
+(function(){
+
+/*jslint node: true, browser: true */
+/*global $tw: false */
+"use strict";
+
+var PREFIX_SUFFIX_LENGTH = 50;
+
+/*
+Build a map of the text content of a dom node and its descendents:
+
+string: concatenation of the text content of child nodes
+metadata: array of {start,end,domNode} where start and end identify position in the string
+*/
+exports.TextMap = function(domNode) {
+	var self = this,
+		stringChunks = [],
+		p = 0;
+	this.metadata = [];
+	var processNode = function(domNode) {
+		// Check for text nodes
+		if(domNode.nodeType === 3) {
+			var text = domNode.textContent;
+			stringChunks.push(text);
+			self.metadata.push({
+				start: p,
+				end: p + text.length,
+				domNode: domNode
+			});
+			p += text.length;
+		} else {
+			// Otherwise look within the child nodes
+			if(domNode.childNodes) {
+				for(var t=0; t<domNode.childNodes.length; t++ ) {
+					processNode(domNode.childNodes[t]);
+				}
+			}
+		}
+	};
+	// Process our text nodes
+	processNode(domNode);
+	this.string = stringChunks.join("");
+};
+
+/*
+Locate the metadata record corresponding to a given position in the string
+*/
+exports.TextMap.prototype.locateMetadata = function(position) {
+	return this.metadata.find(function(metadata) {
+		return position >= metadata.start && position < metadata.end;
+	});
+};
+
+/*
+Search for the first occurance of a target string within the textmap of a dom node
+
+Returns an object with the following properties:
+	startNode: node containing the start of the text
+	startOffset: offset of the start of the text within the node
+	endNode: node containing the end of the text
+	endOffset: offset of the end of the text within the node
+*/
+exports.TextMap.prototype.findText = function(targetString,targetPrefix,targetSuffix) {
+	if(!targetString) {
+		return null;
+	}
+	targetPrefix = targetPrefix || "";
+	targetSuffix = targetSuffix || "";
+	var startPos = this.string.indexOf(targetPrefix + targetString + targetSuffix);
+	if(startPos !== -1) {
+		startPos += targetPrefix.length;
+		var startMetadata = this.locateMetadata(startPos),
+			endMetadata = this.locateMetadata(startPos + targetString.length - 1);
+		if(startMetadata && endMetadata) {
+			return {
+				startNode: startMetadata.domNode,
+				startOffset: startPos - startMetadata.start,
+				endNode: endMetadata.domNode,
+				endOffset: (startPos + targetString.length) - endMetadata.start
+			}			
+		}
+	}
+	return null;
+};
+
+/*
+Search for all occurances of a string within the textmap of a dom node
+
+Options include:
+	mode: "normal", "regexp" or "whitespace"
+	caseSensitive: true if the search should be case sensitive
+
+Returns an array of objects with the following properties:
+	startPos: start position of the match within the string contained by this TextMap
+	startNode: node containing the start of the text
+	startOffset: offset of the start of the text within the node
+	endPos: end position of the match within the string contained by this TextMap
+	endNode: node containing the end of the text
+	endOffset: offset of the end of the text within the node
+*/
+exports.TextMap.prototype.search = function(searchString,options) {
+	if(!searchString) {
+		return [];
+	}
+	options = options || {};
+	// Compose the regexp
+	var regExpString,
+		flags = options.caseSensitive ? "g" : "gi";
+	if(options.mode === "regexp") {
+		regExpString = "(" + searchString + ")";
+	} else if(options.mode === "whitespace") {
+		// Normalise whitespace
+		regExpString = "(" + searchString.split(/\s+/g).filter(function(word) {
+			return !!word
+		}).map($tw.utils.escapeRegExp).join("\\s+") + ")";
+	} else {
+		// Normal search
+		regExpString = "(" + $tw.utils.escapeRegExp(searchString) + ")";
+	}
+	// Compile the regular expression
+	var regExp;
+	try {
+		regExp = RegExp(regExpString,flags);
+	} catch(e) {
+	}
+	if(!regExp) {
+		return [];
+	}
+	// Find each match
+	var results = [],
+		match;
+	do {
+		match = regExp.exec(this.string);
+		if(match) {
+			var metadataStart = this.locateMetadata(match.index),
+				metadataEnd = this.locateMetadata(match.index + match[0].length);
+			if(metadataStart && metadataEnd) {
+				results.push({
+					startPos: match.index,
+					startNode: metadataStart.domNode,
+					startOffset: match.index - metadataStart.start,
+					endPos: match.index + match[0].length,
+					endNode: metadataEnd.domNode,
+					endOffset: match.index + match[0].length - metadataEnd.start
+				});
+			}
+		}
+	} while(match);
+	return results;
+};
+
+/*
+Given a start container and offset and a search string, return a prefix and suffix to disambiguate the text
+*/
+exports.TextMap.prototype.extractContext = function(startContainer,startOffset,text) {
+	var startMetadata = this.metadata.find(function(metadata) {
+			return metadata.domNode === startContainer
+		});
+	if(!startMetadata) {
+		return null;
+	}
+	var startPos = startMetadata.start + startOffset;
+	return {
+		prefix: this.string.slice(Math.max(startPos - PREFIX_SUFFIX_LENGTH, 0), startPos),
+		suffix: this.string.slice(startPos + text.length, Math.min(startPos + text.length + PREFIX_SUFFIX_LENGTH, this.string.length))
+	};
+};
+
+})();

package/plugins/tiddlywiki/dynannotate/plugin.info

@@ -0,0 +1,9 @@
+{
+	"title": "$:/plugins/tiddlywiki/dynannotate",
+	"name": "Dynannotate",
+	"description": "Dynamic content annotation",
+	"author": "JeremyRuston",
+	"core-version": ">=5.0.0",
+	"list": "readme examples",
+	"dependents": ["$:/plugins/tiddlywiki/dynaview"]
+}

package/plugins/tiddlywiki/dynannotate/styles.tid

@@ -0,0 +1,44 @@
+title: $:/plugins/tiddlywiki/dynannotate/styles
+tags: [[$:/tags/Stylesheet]]
+
+\rules only filteredtranscludeinline transcludeinline macrodef macrocallinline
+
+.tc-dynannotation-wrapper {
+	position: relative;
+}
+
+.tc-dynannotation-annotation-overlay {
+	position: absolute;
+	background: rgba(255,255,0,0.3);
+	mix-blend-mode: multiply;
+}
+
+.tc-dynannotation-search-overlay {
+	position: absolute;
+	pointer-events: none;
+	background: rgba(255,0,0,0.3);
+}
+
+.tc-dynannotation-search-overlay-blurred {
+	background: rgba(255,0,0,0.3);
+	mix-blend-mode: multiply;
+	border-radius: 4px;
+	filter: blur(2px);
+}
+
+@keyframes ta-dynannotation-search-overlay-animated { to { background-position: 100% 100% } }
+
+.tc-dynannotation-search-overlay-animated {
+	mix-blend-mode: multiply;
+	background: repeating-linear-gradient(-45deg, #ff8 0, #dd8 25%, transparent 0, transparent 50%) 0 / .6em .6em;
+	animation: ta-dynannotation-search-overlay-animated 12s linear infinite;
+}
+
+.tc-dynannotate-snippet-highlight {
+	background: #efef53;
+}
+
+.tc-dynannotation-example-info {
+	background: #ffa;
+	padding: 1em;
+}

package/plugins/tiddlywiki/dynaview/examples/reveal-on-scroll.tid

@@ -3,21 +3,21 @@ tags: $:/tags/dynaviewExamples
 caption: Reveal on Scroll
 
 \define indicator(index)
-<$reveal state="$:/state/unreveal-on-scroll/example$index$" type="match" text="yes">
+<$reveal state="$:/state/unreveal-on-scroll/example$index$" type="nomatch" text="">
 $index$
 </$reveal>
 \end
 
 \define lorem-ipsum(index)
-<div class="tc-dynaview-set-tiddler-when-visible" style="min-height: 75px;" data-dynaview-set-tiddler="$:/state/unreveal-on-scroll/example$index$" data-dynaview-set-value="yes">
+<div class="tc-dynaview-track-tiddler-when-visible" style="min-height: 75px;" data-dynaview-track-tiddler="$:/state/unreveal-on-scroll/example$index$">
 <h1>Heading $index$</h1>
-<$reveal state="$:/state/unreveal-on-scroll/example$index$" type="match" text="yes">
+<$reveal state="$:/state/unreveal-on-scroll/example$index$" type="nomatch" text="">
 (Rendered at <<now "[UTC]YYYY-0MM-0DD 0hh:0mm:0ss.XXX">>) Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
 </$reveal>
 </div>
 \end
 
-This example renders tiddlers as they are scrolled into view.
+This example renders tiddlers as they are scrolled into view, and hides them when they scroll out of view again.
 
 Visible: <$list filter="1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16">
 <$macrocall $name="indicator" index=<<currentTiddler>>/>

package/plugins/tiddlywiki/dynaview/examples/zoomable-tooltips.tid

@@ -48,7 +48,7 @@ caption: Zoomable Tooltips
 <span class="zoomable-tooltip-demo-item-image">
 <$transclude/>
 </span>
-<span class="zoomable-tooltip-demo-item-text tc-dynaview-zoom-visible-3-and-above">
+<span class="zoomable-tooltip-demo-item-text tc-dynaview-zoom-visible-2-and-above">
 <$text text=<<currentTiddler>>/>
 </span>
 </div>

package/plugins/tiddlywiki/dynaview/macros.tid

@@ -2,13 +2,13 @@ title: $:/plugins/tiddlywiki/dynaview/macros
 tags: $:/tags/Macro
 
 \define transclude-when-visible(tiddler,mode:"block",state,minHeight:"1em",loadingText:"…")
-<$reveal state=<<__state__>> type="match" text="visible" tag="div">
-<div class="tc-dynaview-set-tiddler-when-visible" data-dynaview-set-tiddler=<<__state__>> data-dynaview-set-value="visible">
+<$reveal state=<<__state__>> type="nomatch" text="0" tag="div">
+<div class="tc-dynaview-track-tiddler-when-visible" data-dynaview-track-tiddler=<<__state__>> data-dynaview-set-value="visible">
 <$transclude tiddler=<<__tiddler__>> mode=<<__mode__>>/>
 </div>
 </$reveal>
-<$reveal state=<<__state__>> type="nomatch" text="visible" tag="div">
-<div class="tc-dynaview-set-tiddler-when-visible" style="min-height: $minHeight$;" data-dynaview-set-tiddler=<<__state__>> data-dynaview-set-value="visible">
+<$reveal state=<<__state__>> type="match" text="0" tag="div">
+<div class="tc-dynaview-track-tiddler-when-visible" style="min-height: $minHeight$;" data-dynaview-track-tiddler=<<__state__>> data-dynaview-set-value="visible">
 $loadingText$
 </div>
 </$reveal>

package/plugins/tiddlywiki/dynaview/plugin.info

@@ -1,7 +1,6 @@
 {
 	"title": "$:/plugins/tiddlywiki/dynaview",
+	"name": "Dynaview",
 	"description": "Dynamic scrolling and zooming effects",
-	"author": "JeremyRuston",
-	"core-version": ">=5.0.0",
 	"list": "readme docs examples config"
 }

package/plugins/tiddlywiki/evernote/plugin.info

@@ -1,7 +1,6 @@
 {
 	"title": "$:/plugins/tiddlywiki/evernote",
+	"name": "Evernote",
 	"description": "Evernote migration tools",
-	"author": "JeremyRuston",
-	"core-version": ">=5.0.0",
 	"list": "readme docs"
 }

package/plugins/tiddlywiki/external-attachments/plugin.info

@@ -1,7 +1,6 @@
 {
 	"title": "$:/plugins/tiddlywiki/external-attachments",
-	"description": "External attachment support for TiddlyDesktop et al.",
-	"author": "Jeremy Ruston",
-	"core-version": ">=5.0.0",
+	"name": "External Attachments",
+	"description": "External attachments for TiddlyDesktop",
 	"list": "readme settings"
 }

package/plugins/tiddlywiki/external-attachments/startup.js

@@ -94,7 +94,7 @@ function makePathRelative(sourcepath,rootpath,options) {
 		return sourcepath;
 	}
 	// Move up a directory for each directory left in the root
-	for(p = c; p < rootParts.length; p++) {
+	for(p = c; p < rootParts.length - 1; p++) {
 		outputParts.push("..");
 	}		
 	// Add on the remaining parts of the source path
@@ -106,19 +106,22 @@ function makePathRelative(sourcepath,rootpath,options) {
 
 function test_makePathRelative() {
 	var test = function(sourcepath,rootpath,result,options) {
-		if(makePathRelative(sourcepath,rootpath,options) !== result) {
-			throw "makePathRelative test failed: makePathRelative(" + sourcepath + "," + rootpath + "," + JSON.stringify(options) + ") is not equal to " + result;			
+		var actualResult = makePathRelative(sourcepath,rootpath,options);
+		if(actualResult !== result) {
+			console.log("makePathRelative test failed: makePathRelative(" + sourcepath + "," + rootpath + "," + JSON.stringify(options) + ") is " + actualResult + " and not equal to " + result);			
 		}
 	};
-	test("/Users/me/something/file.png","/Users/you/something","../../me/something/file.png");
-	test("/Users/me/something/file.png","/Users/you/something","/Users/me/something/file.png",{useAbsoluteForNonDescendents: true});
-	test("/Users/me/something/else/file.png","/Users/me/something","else/file.png");
-	test("/Users/me/something/file.png","/Users/me/something/new","../file.png");
-	test("/Users/me/something/file.png","/Users/me/something/new","/Users/me/something/file.png",{useAbsoluteForNonDescendents: true});
-	test("/Users/me/something/file.png","/Users/me/something","file.png");
-	test("C:\\Users\\me\\something\\file.png","/C:/Users/me/something","file.png",{isWindows: true});
-	test("\\\\SHARE\\Users\\me\\something\\file.png","/SHARE/Users/me/somethingelse","../something/file.png",{isWindows: true});
-	test("\\\\SHARE\\Users\\me\\something\\file.png","/C:/Users/me/something","/SHARE/Users/me/something/file.png",{isWindows: true});
+	test("/Users/me/something/file.png","/Users/you/something/index.html","../../me/something/file.png");
+	test("/Users/me/something/file.png","/Users/you/something/index.html","/Users/me/something/file.png",{useAbsoluteForNonDescendents: true});
+	test("/Users/me/something/else/file.png","/Users/me/something/index.html","else/file.png");
+	test("/Users/me/something/file.png","/Users/me/something/new/index.html","../file.png");
+	test("/Users/me/something/file.png","/Users/me/something/new/index.html","/Users/me/something/file.png",{useAbsoluteForNonDescendents: true});
+	test("/Users/me/something/file.png","/Users/me/something/index.html","file.png");
+	test("/Users/jeremyruston/Downloads/Screenshot 2020-10-18 at 15.33.40.png","/Users/jeremyruston/git/Jermolene/TiddlyWiki5/editions/prerelease/output/index.html","../../../../../../Downloads/Screenshot%202020-10-18%20at%2015.33.40.png");
+	test("/Users/me/nothing/image.png","/Users/me/something/a/b/c/d/e/index.html","../../../../../../nothing/image.png");
+	test("C:\\Users\\me\\something\\file.png","/C:/Users/me/something/index.html","file.png",{isWindows: true});
+	test("\\\\SHARE\\Users\\me\\something\\file.png","/SHARE/Users/me/somethingelse/index.html","../something/file.png",{isWindows: true});
+	test("\\\\SHARE\\Users\\me\\something\\file.png","/C:/Users/me/something/index.html","/SHARE/Users/me/something/file.png",{isWindows: true});
 }
 
 

package/plugins/tiddlywiki/filesystem/filesystemadaptor.js

@@ -19,20 +19,25 @@ var fs = $tw.node ? require("fs") : null,
 function FileSystemAdaptor(options) {
 	var self = this;
 	this.wiki = options.wiki;
+	this.boot = options.boot || $tw.boot;
 	this.logger = new $tw.utils.Logger("filesystem",{colour: "blue"});
 	// Create the <wiki>/tiddlers folder if it doesn't exist
-	$tw.utils.createDirectory($tw.boot.wikiTiddlersPath);
+	$tw.utils.createDirectory(this.boot.wikiTiddlersPath);
 }
 
 FileSystemAdaptor.prototype.name = "filesystem";
 
+FileSystemAdaptor.prototype.supportsLazyLoading = false;
+
 FileSystemAdaptor.prototype.isReady = function() {
 	// The file system adaptor is always ready
 	return true;
 };
 
 FileSystemAdaptor.prototype.getTiddlerInfo = function(tiddler) {
-	return {};
+	//Returns the existing fileInfo for the tiddler. To regenerate, call getTiddlerFileInfo().
+	var title = tiddler.fields.title;
+	return this.boot.files[title];
 };
 
 /*
@@ -41,37 +46,69 @@ Return a fileInfo object for a tiddler, creating it if necessary:
   type: the type of the tiddler file (NOT the type of the tiddler -- see below)
   hasMetaFile: true if the file also has a companion .meta file
 
-The boot process populates $tw.boot.files for each of the tiddler files that it loads. The type is found by looking up the extension in $tw.config.fileExtensionInfo (eg "application/x-tiddler" for ".tid" files).
+The boot process populates this.boot.files for each of the tiddler files that it loads.
+The type is found by looking up the extension in $tw.config.fileExtensionInfo (eg "application/x-tiddler" for ".tid" files).
 
-It is the responsibility of the filesystem adaptor to update $tw.boot.files for new files that are created.
+It is the responsibility of the filesystem adaptor to update this.boot.files for new files that are created.
 */
 FileSystemAdaptor.prototype.getTiddlerFileInfo = function(tiddler,callback) {
-	// See if we've already got information about this file
-	var title = tiddler.fields.title,
-		fileInfo = $tw.boot.files[title];
-	if(!fileInfo) {
-		// Otherwise, we'll need to generate it
-		fileInfo = $tw.utils.generateTiddlerFileInfo(tiddler,{
-			directory: $tw.boot.wikiTiddlersPath,
-			pathFilters: this.wiki.getTiddlerText("$:/config/FileSystemPaths","").split("\n"),
-			wiki: this.wiki
-		});
-		$tw.boot.files[title] = fileInfo;
+	// Always generate a fileInfo object when this fuction is called
+	var title = tiddler.fields.title, newInfo, pathFilters, extFilters,
+		fileInfo = this.boot.files[title];
+	if(this.wiki.tiddlerExists("$:/config/FileSystemPaths")) {
+		pathFilters = this.wiki.getTiddlerText("$:/config/FileSystemPaths","").split("\n");
 	}
-	callback(null,fileInfo);
+	if(this.wiki.tiddlerExists("$:/config/FileSystemExtensions")) {
+		extFilters = this.wiki.getTiddlerText("$:/config/FileSystemExtensions","").split("\n");
+	}
+	newInfo = $tw.utils.generateTiddlerFileInfo(tiddler,{
+		directory: this.boot.wikiTiddlersPath,
+		pathFilters: pathFilters,
+		extFilters: extFilters,
+		wiki: this.wiki,
+		fileInfo: fileInfo
+	});
+	callback(null,newInfo);
 };
 
 
 /*
 Save a tiddler and invoke the callback with (err,adaptorInfo,revision)
 */
-FileSystemAdaptor.prototype.saveTiddler = function(tiddler,callback) {
+FileSystemAdaptor.prototype.saveTiddler = function(tiddler,callback,options) {
 	var self = this;
+	var syncerInfo = options.tiddlerInfo || {};
 	this.getTiddlerFileInfo(tiddler,function(err,fileInfo) {
 		if(err) {
 			return callback(err);
 		}
-		$tw.utils.saveTiddlerToFile(tiddler,fileInfo,callback);
+		$tw.utils.saveTiddlerToFile(tiddler,fileInfo,function(err,fileInfo) {
+			if(err) {
+				if ((err.code == "EPERM" || err.code == "EACCES") && err.syscall == "open") {
+					fileInfo = fileInfo || self.boot.files[tiddler.fields.title];
+					fileInfo.writeError = true;
+					self.boot.files[tiddler.fields.title] = fileInfo;
+					$tw.syncer.logger.log("Sync failed for \""+tiddler.fields.title+"\" and will be retried with encoded filepath",encodeURIComponent(fileInfo.filepath));
+					return callback(err);
+				} else {
+					return callback(err);
+				}
+			}
+			// Store new boot info only after successful writes
+			self.boot.files[tiddler.fields.title] = fileInfo;
+			// Cleanup duplicates if the file moved or changed extensions
+			var options = {
+				adaptorInfo: syncerInfo.adaptorInfo || {},
+				bootInfo: fileInfo || {},
+				title: tiddler.fields.title
+			};
+			$tw.utils.cleanupTiddlerFiles(options,function(err,fileInfo) {
+				if(err) {
+					return callback(err);
+				}
+				return callback(null,fileInfo);
+			});
+		});
 	});
 };
 
@@ -89,28 +126,25 @@ Delete a tiddler and invoke the callback with (err)
 */
 FileSystemAdaptor.prototype.deleteTiddler = function(title,callback,options) {
 	var self = this,
-		fileInfo = $tw.boot.files[title];
+		fileInfo = this.boot.files[title];
 	// Only delete the tiddler if we have writable information for the file
 	if(fileInfo) {
-		// Delete the file
-		fs.unlink(fileInfo.filepath,function(err) {
+		$tw.utils.deleteTiddlerFile(fileInfo,function(err,fileInfo) {
 			if(err) {
-				return callback(err);
-			}
-			// Delete the metafile if present
-			if(fileInfo.hasMetaFile) {
-				fs.unlink(fileInfo.filepath + ".meta",function(err) {
-					if(err) {
-						return callback(err);
-					}
-					return $tw.utils.deleteEmptyDirs(path.dirname(fileInfo.filepath),callback);
-				});
-			} else {
-				return $tw.utils.deleteEmptyDirs(path.dirname(fileInfo.filepath),callback);
+				if ((err.code == "EPERM" || err.code == "EACCES") && err.syscall == "unlink") {
+					// Error deleting the file on disk, should fail gracefully
+					$tw.syncer.displayError("Server desynchronized. Error deleting file for deleted tiddler \"" + title + "\"",err);
+					return callback(null,fileInfo);
+				} else {
+					return callback(err);
+				}
 			}
+			// Remove the tiddler from self.boot.files & return null adaptorInfo
+			delete self.boot.files[title];
+			return callback(null,null);
 		});
 	} else {
-		callback(null);
+		callback(null,null);
 	}
 };
 

package/plugins/tiddlywiki/filesystem/plugin.info

@@ -1,7 +1,6 @@
 {
 	"title": "$:/plugins/tiddlywiki/filesystem",
-	"description": "Local filesystem syncadaptor",
-	"author": "JeremyRuston",
-	"core-version": ">=5.0.0",
+	"name": "Filesystem",
+	"description": "Synchronize changes from the node.js server to the local filesystem",
 	"list": "readme"
 }

package/plugins/tiddlywiki/freelinks/config-Freelinks-Enable.tid

@@ -0,0 +1,2 @@
+title: $:/config/Freelinks/Enable
+text: yes

package/plugins/tiddlywiki/freelinks/macros-view.tid

@@ -0,0 +1,8 @@
+title: $:/plugins/tiddlywiki/freelinks/macros/view
+tags: $:/tags/Macro/View
+
+<$set name="tv-freelinks" value={{$:/config/Freelinks/Enable}}>
+
+<$set name="tv-freelinks-ignore-case" value={{$:/config/Freelinks/IgnoreCase}}/>
+
+</$set>