tiddlywiki 5.3.8 → 5.4.0

package/plugins/tiddlywiki/wikitext-serialize/rules/list.js

@@ -0,0 +1,76 @@
+/*\
+title: $:/plugins/tiddlywiki/wikitext-serialize/rules/list.js
+type: application/javascript
+module-type: wikiruleserializer
+\*/
+
+"use strict";
+
+exports.name = "list";
+
+var listTypes = require("$:/core/modules/parsers/wikiparser/rules/list.js").listTypes;
+var listTags = Object.values(listTypes).map(function(type) {
+	return type.listTag;
+});
+/*
+Check if the child is a nested list or a simple line of list item
+*/
+function isListNode(node) {
+	return node && node.type === "element" && listTags.includes(node.tag);
+}
+var itemTags = Object.values(listTypes).map(function(type) {
+	return type.itemTag;
+});
+
+exports.serialize = function (tree,serialize) {
+	// Helper function to find the marker for a given list container tag and item tag
+	function findMarker(listTag, itemTag) {
+		for(var key in listTypes) {
+			if(listTypes[key].listTag === listTag && listTypes[key].itemTag === itemTag) {
+				return key; // Return the marker associated with the list tag and item tag
+			}
+		}
+		return ""; // Return empty string if no matching marker is found
+	}
+
+	// Recursive function to serialize list nodes, handling nested lists and formatting output
+	function serializeList(node, markerPrefix) {
+		var result = [];
+		if(node.type === "element" && isListNode(node)) {
+			node.children.forEach(function (child) {
+				if(itemTags.includes(child.tag)) {
+					var currentMarker = findMarker(node.tag, child.tag);
+					// Handle class attributes
+					var classAttr = child.attributes && child.attributes.class ? "." + child.attributes.class.value : "";
+					/** 
+					 * same level text nodes may be split into multiple children, and separated by deeper list sub-tree.
+					 * We collect same level text nodes into this list, and concat then submit them before enter deeper list.
+					 */
+					var content = [];
+					$tw.utils.each(child.children,function (subNode) {
+						if(isListNode(subNode)) {
+							// Recursive call for nested lists
+							if(content.length > 0) {
+								result.push(markerPrefix + currentMarker + classAttr + " " + content.join("").trim());
+								content = [];
+							}
+							result.push(serializeList(subNode, markerPrefix + currentMarker).trim());
+						} else {
+							content.push(serialize(subNode)) ;
+						}
+						return ""; // Default return for unhandled node types
+					});
+					// prepend `#` mark to a new line, if it has content (and has or hasn't nested list), or if it has no content and also no nested list
+					if(content.length > 0 || child.children.length === 0) {
+						result.push(markerPrefix + currentMarker + classAttr + " " + content.join("").trim());
+						content = [];
+					}
+				}
+			});
+		}
+		return result.join("\n");
+	}
+
+	// Begin serialization from the root node, with an empty string as the initial marker prefix
+	return serializeList(tree, "") + "\n\n";
+};

package/plugins/tiddlywiki/wikitext-serialize/rules/macrocallblock.js

@@ -0,0 +1,27 @@
+/*\
+title: $:/plugins/tiddlywiki/wikitext-serialize/rules/macrocallblock.js
+type: application/javascript
+module-type: wikiruleserializer
+\*/
+
+"use strict";
+
+exports.name = "macrocallblock";
+
+exports.serialize = function (node) {
+	var result = "<<";
+	// Macro name
+	if(node.attributes && node.attributes["$variable"]) {
+		result += node.attributes["$variable"].value;
+	}
+	// Append ordered arguments if any
+	if(node.orderedAttributes) {
+		node.orderedAttributes.forEach(function (attribute) {
+			if(attribute.name !== "$variable") {
+				result += " " + $tw.utils.serializeAttribute(attribute);
+			}
+		});
+	}
+	result += ">>\n\n";
+	return result;
+};

package/plugins/tiddlywiki/wikitext-serialize/rules/macrocallinline.js

@@ -0,0 +1,15 @@
+/*\
+title: $:/plugins/tiddlywiki/wikitext-serialize/rules/macrocallinline.js
+type: application/javascript
+module-type: wikiruleserializer
+\*/
+
+"use strict";
+
+exports.name = "macrocallinline";
+
+exports.serialize = function (tree,serialize) {
+	var macrocallblock = require("$:/plugins/tiddlywiki/wikitext-serialize/rules/macrocallblock.js");
+	var result = macrocallblock.serialize(tree,serialize);
+	return result.trimEnd();
+};

package/plugins/tiddlywiki/wikitext-serialize/rules/macrodef.js

@@ -0,0 +1,21 @@
+/*\
+title: $:/plugins/tiddlywiki/wikitext-serialize/rules/macrodef.js
+type: application/javascript
+module-type: wikiruleserializer
+\*/
+
+"use strict";
+
+exports.name = "macrodef";
+
+exports.serialize = function(tree,serialize) {
+	var name = tree.attributes.name.value;
+	var params = tree.params.map(function(param) {
+		return param.name + (param.default ? ":" + param.default : "");
+	}).join(",");
+	var definition = tree.attributes.value.value;
+	if(tree.isBlock) {
+		return "\\define " + name + "(" + params + ") " + definition + "\n\n" + serialize(tree.children);
+	}
+	return "\\define " + name + "(" + params + ")\n" + definition + "\n\\end\n\n" + serialize(tree.children);
+};

package/plugins/tiddlywiki/wikitext-serialize/rules/parameters.js

@@ -0,0 +1,16 @@
+/*\
+title: $:/plugins/tiddlywiki/wikitext-serialize/rules/parameters.js
+type: application/javascript
+module-type: wikiruleserializer
+\*/
+
+"use strict";
+
+exports.name = "parameters";
+
+exports.serialize = function(tree,serialize) {
+	var params = tree.orderedAttributes.map(function(param) {
+		return param.name + (param.value ? ":" + param.value : "");
+	}).join(",");
+	return "\\parameters(" + params + ")\n\n" + serialize(tree.children);
+};

package/plugins/tiddlywiki/wikitext-serialize/rules/parsermode.js

@@ -0,0 +1,14 @@
+/*\
+title: $:/plugins/tiddlywiki/wikitext-serialize/rules/parsermode.js
+type: application/javascript
+module-type: wikiruleserializer
+\*/
+
+"use strict";
+
+exports.name = "parsermode";
+
+exports.serialize = function(tree,serialize) {
+	var mode = tree.parseAsInline ? "inline" : "block";
+	return "\\parsermode " + mode + "\n\n" + serialize(tree.children);
+};

package/plugins/tiddlywiki/wikitext-serialize/rules/prettyextlink.js

@@ -0,0 +1,15 @@
+/*\
+title: $:/plugins/tiddlywiki/wikitext-serialize/rules/prettyextlink.js
+type: application/javascript
+module-type: wikiruleserializer
+\*/
+
+"use strict";
+
+exports.name = "prettyextlink";
+
+exports.serialize = function(tree,serialize) {
+	var tooltip = tree.children[0].text;
+	var url = tree.attributes.href.value;
+	return "[ext[" + (tooltip !== url ? tooltip + "|" : "") + url + "]]";
+};

package/plugins/tiddlywiki/wikitext-serialize/rules/prettylink.js

@@ -0,0 +1,15 @@
+/*\
+title: $:/plugins/tiddlywiki/wikitext-serialize/rules/prettylink.js
+type: application/javascript
+module-type: wikiruleserializer
+\*/
+
+"use strict";
+
+exports.name = "prettylink";
+
+exports.serialize = function(tree,serialize) {
+	var text = tree.children[0].text;
+	var target = tree.attributes.to ? tree.attributes.to.value : tree.attributes.href.value;
+	return "[[" + text + (text !== target ? "|" + target : "") + "]]";
+};

package/plugins/tiddlywiki/wikitext-serialize/rules/quoteblock.js

@@ -0,0 +1,24 @@
+/*\
+title: $:/plugins/tiddlywiki/wikitext-serialize/rules/quoteblock.js
+type: application/javascript
+module-type: wikiruleserializer
+\*/
+
+"use strict";
+
+exports.name = "quoteblock";
+
+exports.serialize = function (tree,serialize) {
+	var result = [];
+	if(tree.type === "element" && tree.tag === "blockquote") {
+		// tree.attributes.class.value: "tc-quote"
+		result.push("<<<" + tree.attributes.class.value);
+		tree.children.forEach(function (child) {
+			if(child.type === "element" && child.tag === "p") {
+				result.push(serialize(child.children).trim());
+			}
+		});
+		result.push("<<<");
+	}
+	return result.join("\n") + "\n\n";
+};

package/plugins/tiddlywiki/wikitext-serialize/rules/rules.js

@@ -0,0 +1,26 @@
+/*\
+title: $:/plugins/tiddlywiki/wikitext-serialize/rules/rules.js
+type: application/javascript
+module-type: wikiruleserializer
+\*/
+
+"use strict";
+
+exports.name = "rules";
+
+exports.serialize = function (tree,serialize) {
+	var result = [];
+	if(tree.attributes.action && tree.attributes.rules) {
+		// tree.attributes.action.value: "except"
+		// tree.attributes.rules.value: "ruleone ruletwo rulethree"
+		result.push("\\rules " + tree.attributes.action.value + " " + tree.attributes.rules.value);
+		tree.children.forEach(function (child) {
+			if(child.type === "void" && child.attributes.action && child.attributes.rules) {
+				// child.attributes.action.value: "only"
+				// child.attributes.rules.value: "ruleone ruletwo rulethree"
+				result.push("\\rules " + child.attributes.action.value + " " + child.attributes.rules.value);
+			}
+		});
+	}
+	return result.join("\n");
+};

package/plugins/tiddlywiki/wikitext-serialize/rules/styleblock.js

@@ -0,0 +1,57 @@
+/*\
+title: $:/plugins/tiddlywiki/wikitext-serialize/rules/styleblock.js
+type: application/javascript
+module-type: wikiruleserializer
+\*/
+
+"use strict";
+
+exports.name = "styleblock";
+
+exports.serialize = function(tree,serialize) {
+	var lines = [];
+	var classes = [];
+	var styles = [];
+
+	// Same classes are set to each children. So only collect from first child.
+	var node = tree.children[0];
+	if(node && node.attributes && node.attributes.class) {
+		var nodeClasses = node.attributes.class.value.split(" ");
+		for(var j = 0; j < nodeClasses.length; j++) {
+			if(classes.indexOf(nodeClasses[j]) === -1) {
+				classes.push(nodeClasses[j]);
+			}
+		}
+	}
+	if(node && node.attributes && node.attributes.style) {
+		var nodeStyles = node.attributes.style.value.split(";");
+		for(var k = 0; k < nodeStyles.length; k++) {
+			var style = nodeStyles[k].trim();
+			if(style && styles.indexOf(style) === -1) {
+				styles.push(style);
+			}
+		}
+	}
+
+	// Add the style block header, sort styles first, and classes later. Original order is not preserved intentionally for simplicity.
+	if(classes.length > 0 || styles.length > 0) {
+		if(styles.length > 0) {
+			lines.push("@@");
+			lines.push(styles.join(";"));
+			lines.push(";\n");
+		}
+		if(classes.length > 0) {
+			lines.push("@@.");
+			lines.push(classes.join("."));
+			lines.push("\n");
+		}
+	}
+	// Serialize each child node and add to result
+	for(var i = 0; i < tree.children.length; i++) {
+		lines.push(serialize(tree.children[i]));
+	}
+	var result = lines.join("").replace(/\s+$/, "");
+	// Add the closing @@ for the style block
+	result += "\n@@\n\n";
+	return result;
+};

package/plugins/tiddlywiki/wikitext-serialize/rules/styleinline.js

@@ -0,0 +1,28 @@
+/*\
+title: $:/plugins/tiddlywiki/wikitext-serialize/rules/styleinline.js
+type: application/javascript
+module-type: wikiruleserializer
+\*/
+
+"use strict";
+
+exports.name = "styleinline";
+
+exports.serialize = function(tree,serialize) {
+	var result = "@@";
+	// Add styles if present
+	if(tree.attributes && tree.attributes.style) {
+		result += tree.attributes.style.value.trim();
+	}
+	// Add classes if present
+	if(tree.attributes && tree.attributes.class) {
+		result += "." + tree.attributes.class.value.trim().split(" ").join(".");
+	}
+	var children = serialize(tree.children);
+	// Ensure at least one space after the style/class
+	if(children && children[0] !== " ") {
+		result += " ";
+	}
+	result += children + "@@";
+	return result;
+};

package/plugins/tiddlywiki/wikitext-serialize/rules/syslink.js

@@ -0,0 +1,18 @@
+/*\
+title: $:/plugins/tiddlywiki/wikitext-serialize/rules/syslink.js
+type: application/javascript
+module-type: wikiruleserializer
+\*/
+
+"use strict";
+
+exports.name = "syslink";
+
+exports.serialize = function(tree,serialize) {
+	// Check if the link is suppressed. Tree may only have text, no children and attributes
+	var isSuppressed = tree.children && tree.children[0].text.substr(0,1) === "~";
+	var serialized = isSuppressed ? "~" : "";
+	// Append the link text
+	serialized += tree.attributes ? tree.attributes.to.value : tree.text;
+	return serialized;
+};

package/plugins/tiddlywiki/wikitext-serialize/rules/table.js

@@ -0,0 +1,39 @@
+/*\
+title: $:/plugins/tiddlywiki/wikitext-serialize/rules/table.js
+type: application/javascript
+module-type: wikiruleserializer
+\*/
+
+"use strict";
+
+exports.name = "table";
+
+exports.serialize = function(tree,serialize) {
+	var serialized = "";
+	// Iterate over the table rows
+	for(var i = 0; i < tree.children.length; i++) {
+		var rowContainer = tree.children[i];
+		// Iterate over the rows in the row container
+		for(var j = 0; j < rowContainer.children.length; j++) {
+			var row = rowContainer.children[j];
+			// Start the row
+			serialized += "|";
+			// Iterate over the cells in the row
+			for(var k = 0; k < row.children.length; k++) {
+				var cell = row.children[k];
+				// if is th, append additional `!`
+				if(cell.tag === "th") {
+					serialized += "!";
+				}
+				// Cell content
+				serialized += serialize(cell.children);
+				// End the cell
+				serialized += "|";
+			}
+			// End the row
+			serialized += "\n";
+		}
+	}
+	// Return the completed block
+	return serialized + "\n";
+};

package/plugins/tiddlywiki/wikitext-serialize/rules/transcludeblock.js

@@ -0,0 +1,57 @@
+/*\
+title: $:/plugins/tiddlywiki/wikitext-serialize/rules/transcludeblock.js
+type: application/javascript
+module-type: wikiruleserializer
+\*/
+
+"use strict";
+
+exports.name = "transcludeblock";
+
+exports.serialize = function(tree,serialize) {
+	var result = "{{";
+	function handleTransclude(transcludeNode) {
+		// Handle field
+		if(transcludeNode.attributes.$field) {
+			result += "!!" + transcludeNode.attributes.$field.value;
+		}
+		// Check for index attribute
+		if(transcludeNode.attributes.$index) {
+			result += "##" + transcludeNode.attributes.$index.value;
+		}
+		// Handle template
+		var tiddlerTitle = tree.attributes.tiddler ? tree.attributes.tiddler.value : undefined;
+		if(transcludeNode.attributes.$tiddler && transcludeNode.attributes.$tiddler.value !== tiddlerTitle) {
+			result += "||" + transcludeNode.attributes.$tiddler.value;
+		}
+		// Check for parameters
+		var params = [];
+		var excludedAttributes = ["tiddler", "$tiddler", "$field", "$index", "$template"];
+		for(var key in transcludeNode.attributes) {
+			if(excludedAttributes.indexOf(key) === -1) {
+				params.push(transcludeNode.attributes[key].value);
+			}
+		}
+		if(params.length > 0) {
+			result += "|" + params.join("|");
+		}
+	}
+	function handleTiddler(tiddlerNode) {
+		// Check for tiddler attribute
+		if(tree.attributes.tiddler.value) { 
+			result += tree.attributes.tiddler.value;
+		}
+		$tw.utils.each(tree.children, function(child) {
+			if(child.type === "transclude") {
+				handleTransclude(child);
+			}
+		});
+	}
+	if(tree.type === "tiddler") {
+		handleTiddler(tree);
+	} else if(tree.type === "transclude") {
+		handleTransclude(tree);
+	}
+	result += "}}\n\n";
+	return result;
+};

package/plugins/tiddlywiki/wikitext-serialize/rules/transcludeinline.js

@@ -0,0 +1,15 @@
+/*\
+title: $:/plugins/tiddlywiki/wikitext-serialize/rules/transcludeinline.js
+type: application/javascript
+module-type: wikiruleserializer
+\*/
+
+"use strict";
+
+exports.name = "transcludeinline";
+
+exports.serialize = function(tree,serialize) {
+	var transcludeblock = require("$:/plugins/tiddlywiki/wikitext-serialize/rules/transcludeblock.js");
+	var result = transcludeblock.serialize(tree,serialize);
+	return result.trimEnd();
+};

package/plugins/tiddlywiki/wikitext-serialize/rules/typedblock.js

@@ -0,0 +1,16 @@
+/*\
+title: $:/plugins/tiddlywiki/wikitext-serialize/rules/typedblock.js
+type: application/javascript
+module-type: wikiruleserializer
+\*/
+
+"use strict";
+
+exports.name = "typedblock";
+
+exports.serialize = function (tree,serialize) {
+	if(tree.type === "void") {
+		return "$$$" + tree.parseType + (tree.renderType ? " > " + tree.renderType : "") + "\n" + tree.text + "\n$$$\n\n";
+	}
+	return "";
+};

package/plugins/tiddlywiki/wikitext-serialize/rules/wikilink.js

@@ -0,0 +1,17 @@
+/*\
+title: $:/plugins/tiddlywiki/wikitext-serialize/rules/wikilink.js
+type: application/javascript
+module-type: wikiruleserializer
+\*/
+
+"use strict";
+
+exports.name = "wikilink";
+
+exports.serialize = function(tree,serialize) {
+	var isSuppressed = tree.children && tree.children[0].text.substr(0,1) === $tw.config.textPrimitives.unWikiLink;
+
+	var serialized = isSuppressed ? $tw.config.textPrimitives.unWikiLink : "";
+	serialized += tree.attributes ? tree.attributes.to.value : tree.text;
+	return serialized;
+};

package/plugins/tiddlywiki/wikitext-serialize/rules/wikilinkprefix.js

@@ -0,0 +1,15 @@
+/*\
+title: $:/plugins/tiddlywiki/wikitext-serialize/rules/wikilinkprefix.js
+type: application/javascript
+module-type: wikiruleserializer
+\*/
+
+"use strict";
+
+exports.name = "wikilinkprefix";
+
+exports.serialize = function(tree,serialize) {
+	var serialized = $tw.config.textPrimitives.unWikiLink;
+	serialized += tree.text;
+	return serialized;
+};

package/plugins/tiddlywiki/wikitext-serialize/utils/parsetree.js

@@ -0,0 +1,132 @@
+/*\
+title: $:/plugins/tiddlywiki/wikitext-serialize/utils/parsetree.js
+type: application/javascript
+module-type: utils
+
+Parse tree utility functions.
+
+\*/
+
+"use strict";
+
+function initSerializers(Parser) {
+	if(Parser && !Parser.prototype.serializers) {
+		Parser.prototype.serializers = {};
+		$tw.modules.forEachModuleOfType("wikiruleserializer",function(title,module) {
+			var rule = module.name;
+			var serialize = module.serialize;
+			Parser.prototype.serializers[rule] = serialize;
+		});
+	}
+};
+
+/*
+Utility to get the (similarly but not 1:1 equal) original wikitext of a parse tree node or array of nodes.
+Based on `node.rule` metadata added in `wikiparser.js`.
+*/
+exports.serializeWikitextParseTree = function serializeWikitextParseTree(tree,options) {
+	options = options || {};
+	var output = [];
+	if($tw.utils.isArray(tree)) {
+		$tw.utils.each(tree,function(node) {
+			output.push(serializeWikitextParseTree(node,options));
+		});
+	} else if(tree) {
+		if(tree.type === "text" && !tree.rule) {
+			output.push(tree.text);
+		} else {
+			var Parser = $tw.utils.getParser("text/vnd.tiddlywiki");
+			// initialize the serializers only once on first use
+			initSerializers(Parser);
+			var serializeOneRule = Parser.prototype.serializers[tree.rule];
+			if(serializeOneRule) {
+				output.push(serializeOneRule(tree,serializeWikitextParseTree));
+			} else if(tree.rule === "parseblock") {
+				output.push(serializeWikitextParseTree(tree.children,options),"\n\n");
+			} else {
+				// when no rule is found, just serialize the children, for example the void nodes
+				output.push(serializeWikitextParseTree(tree.children,options));
+			}
+		}
+	}
+	return output.join("");
+};
+
+/*
+Serialize a parsed attribute node
+*/
+exports.serializeAttribute = function(node,options) {
+	options = options || {};
+	if(!node || typeof node !== "object" || !node.name || !node.type) {
+		return null;
+	}
+	// If name is number, means it is a positional attribute and name is omitted
+	var positional = parseInt(node.name) >= 0,
+		// Use the original assignment operator if available, otherwise default to '='
+		assign = positional ? "" : (node.assignmentOperator || "="),
+		attributeString = positional ? "" : node.name;
+	if(node.type === "string") {
+		if(node.value === "true") {
+			return attributeString;
+		}
+		// For macro parameters (using ':' separator), preserve unquoted values
+		// For widget attributes (using '=' separator), always use quotes
+		if(assign === ":" && !node.quoted) {
+			attributeString += assign + node.value;
+		} else if(assign === "") {
+			// Positional parameter
+			if(!node.quoted) {
+				attributeString += node.value;
+			} else {
+				attributeString += '"' + node.value + '"';
+			}
+		} else {
+			attributeString += assign + '"' + node.value + '"';
+		}
+	} else if(node.type === "filtered") {
+		attributeString += assign + "{{{" + node.filter + "}}}";
+	} else if(node.type === "indirect") {
+		attributeString += assign + "{{" + node.textReference + "}}";
+	} else if(node.type === "substituted") {
+		attributeString += assign + "`" + node.rawValue + "`";
+	} else if(node.type === "macro") {
+		if(node.value && typeof node.value === "object") {
+			if(node.value.type === "transclude") {
+				// Handle the transclude-based macro call structure
+				var macroName = node.value.attributes && node.value.attributes["$variable"] ? 
+					node.value.attributes["$variable"].value : "";
+				if(!macroName) {
+					return null;
+				}
+				var params = [];
+				if(node.value.orderedAttributes) {
+					node.value.orderedAttributes.forEach(function(attr) {
+						if(attr.name !== "$variable") {
+							var paramStr = exports.serializeAttribute(attr);
+							if(paramStr) {
+								params.push(paramStr);
+							}
+						}
+					});
+				}
+				attributeString += assign + "<<" + macroName + (params.length > 0 ? " " + params.join(" ") : "") + ">>";
+			} else if(node.value.type === "macrocall") {
+				// Handle the classical macrocall structure for backwards compatibility
+				var params = node.value.params.map(function(param) {
+					return param.value;
+				}).join(" ");
+				attributeString += assign + "<<" + node.value.name + " " + params + ">>";
+			} else {
+				// Unsupported macro structure
+				return null;
+			}
+		} else {
+			// Unsupported macro structure
+			return null;
+		}
+	} else {
+		// Unsupported type
+		return null;
+	}
+	return attributeString;
+};

package/plugins/tiddlywiki/xlsx-utils/deserializer.js

@@ -14,8 +14,7 @@ Parse an XLSX file into tiddlers
 */
 exports["application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"] = function(text,fields) {
 	// Collect output tiddlers in an array
-	var results = [],
-		XLSXImporter = require("$:/plugins/tiddlywiki/xlsx-utils/importer.js").XLSXImporter,
+	var XLSXImporter = require("$:/plugins/tiddlywiki/xlsx-utils/importer.js").XLSXImporter,
 		importer = new XLSXImporter({
 			text: text,
 			wiki: $tw.wiki