tiddlywiki 5.3.8 → 5.4.0

package/core/modules/widgets/widget.js

@@ -80,7 +80,7 @@ Widget.prototype.execute = function() {
 /*
 Set the value of a context variable
 name: name of the variable
-value: value of the variable
+value: value of the variable, can be a string or an array
 params: array of {name:, default:} for each parameter
 isMacroDefinition: true if the variable is set via a \define macro pragma (and hence should have variable substitution performed)
 options includes:
@@ -90,8 +90,10 @@ options includes:
 */
 Widget.prototype.setVariable = function(name,value,params,isMacroDefinition,options) {
 	options = options || {};
+	var valueIsArray = $tw.utils.isArray(value);
 	this.variables[name] = {
-		value: value,
+		value: valueIsArray ? (value[0] || "") : value,
+		resultList: valueIsArray ? value : [value],
 		params: params,
 		isMacroDefinition: !!isMacroDefinition,
 		isFunctionDefinition: !!options.isFunctionDefinition,
@@ -114,7 +116,7 @@ allowSelfAssigned: if true, includes the current widget in the context chain ins
 
 Returns an object with the following fields:
 
-params: array of {name:,value:} or {value:} of parameters to be applied
+params: array of {name:,value:,multiValue:} of parameters to be applied (name is optional)
 text: text of variable, with parameters properly substituted
 resultList: result of variable evaluation as an array
 srcVariable: reference to the object defining the variable
@@ -140,27 +142,36 @@ Widget.prototype.getVariableInfo = function(name,options) {
 			params = self.resolveVariableParameters(variable.params,actualParams);
 			// Substitute any parameters specified in the definition
 			$tw.utils.each(params,function(param) {
-				value = $tw.utils.replaceString(value,new RegExp("\\$" + $tw.utils.escapeRegExp(param.name) + "\\$","mg"),param.value);
+				if("name" in param) {
+					value = $tw.utils.replaceString(value,new RegExp("\\$" + $tw.utils.escapeRegExp(param.name) + "\\$","mg"),param.value);
+				}
 			});
 			value = self.substituteVariableReferences(value,options);
 			resultList = [value];
 		} else if(variable.isFunctionDefinition) {
 			// Function evaluations
 			params = self.resolveVariableParameters(variable.params,actualParams);
-			var variables = options.variables || Object.create(null);
+			var variables = $tw.utils.extend({},options.variables);
 			// Apply default parameter values
 			$tw.utils.each(variable.params,function(param,index) {
 				if(param["default"]) {
 					variables[param.name] = param["default"];
 				}
 			});
-			// Parameters are an array of {value:} or {name:, value:} pairs
+			// Parameters are an array of {name:, value:, multivalue:} pairs (name and multivalue are optional)
 			$tw.utils.each(params,function(param) {
-				variables[param.name] = param.value;
+				if(param.multiValue && param.multiValue.length) {
+					variables[param.name] = param.multiValue;
+				} else {
+					variables[param.name] = param.value || "";
+				}
 			});
 			resultList = this.wiki.filterTiddlers(value,this.makeFakeWidgetWithVariables(variables),options.source);
 			value = resultList[0] || "";
 		} else {
+			if(variable.resultList) {
+				resultList = variable.resultList;
+			}
 			params = variable.params;
 		}
 		return {
@@ -178,7 +189,7 @@ Widget.prototype.getVariableInfo = function(name,options) {
 	}
 	return {
 		text: text,
-		resultList: [text]
+		resultList: text === undefined ? text : [text]
 	};
 };
 
@@ -192,22 +203,24 @@ Widget.prototype.getVariable = function(name,options) {
 /*
 Maps actual parameters onto formal parameters, returning an array of {name:,value:} objects
 formalParams - Array of {name:,default:} (default value is optional)
-actualParams - Array of string values or {name:,value:} (name is optional)
+actualParams - Array of string values or {name:,value:,multiValue} (name and multiValue is optional)
 */
 Widget.prototype.resolveVariableParameters = function(formalParams,actualParams) {
 	formalParams = formalParams || [];
 	actualParams = actualParams || [];
 	var nextAnonParameter = 0, // Next candidate anonymous parameter in macro call
-		paramInfo, paramValue,
+		paramInfo, paramValue, paramMultiValue,
 		results = [];
 	// Step through each of the parameters in the macro definition
 	for(var p=0; p<formalParams.length; p++) {
 		// Check if we've got a macro call parameter with the same name
 		paramInfo = formalParams[p];
 		paramValue = undefined;
+		paramMultiValue = undefined;
 		for(var m=0; m<actualParams.length; m++) {
 			if(typeof actualParams[m] !== "string" && actualParams[m].name === paramInfo.name) {
 				paramValue = actualParams[m].value;
+				paramMultiValue = actualParams[m].multiValue || [paramValue];
 			}
 		}
 		// If not, use the next available anonymous macro call parameter
@@ -217,11 +230,15 @@ Widget.prototype.resolveVariableParameters = function(formalParams,actualParams)
 		if(paramValue === undefined && nextAnonParameter < actualParams.length) {
 			var param = actualParams[nextAnonParameter++];
 			paramValue = typeof param === "string" ? param : param.value;
+			paramMultiValue = typeof param === "string" ? [param] : (param.multiValue || [paramValue]);
 		}
 		// If we've still not got a value, use the default, if any
-		paramValue = paramValue || paramInfo["default"] || "";
+		if(!paramValue) {
+			paramValue = paramInfo["default"] || "";
+			paramMultiValue = [paramValue];
+		}
 		// Store the parameter name and value
-		results.push({name: paramInfo.name, value: paramValue});
+		results.push({name: paramInfo.name, value: paramValue, multiValue: paramMultiValue});
 	}
 	return results;
 };
@@ -310,76 +327,135 @@ Widget.prototype.getStateQualifier = function(name) {
 };
 
 /*
-Make a fake widget with specified variables, suitable for variable lookup in filters
+Make a fake widget with specified variables, suitable for variable lookup in filters. Each variable can be a string or an array of strings
 */
-Widget.prototype.makeFakeWidgetWithVariables = function(variables) {
-	var self = this,
-		variables = variables || {};
-	return {
-		getVariable: function(name,opts) {
-			if($tw.utils.hop(variables,name)) {
-				return variables[name];
-			} else {
-				opts = opts || {};
-				opts.variables = variables;
-				return self.getVariable(name,opts);
-			};
+Widget.prototype.makeFakeWidgetWithVariables = function(vars = {}) {
+	const self = this;
+
+	const fakeWidget = {
+		getVariableInfo(name,opts = {}) {
+			if(name in vars) {
+				const value = vars[name];
+				return Array.isArray(value)
+					? { text: value[0], resultList: value }
+					: { text: value, resultList: value === undefined ? value : [value] };
+			}
+			opts = opts || {};
+			opts.variables = Object.assign({}, vars, opts.variables || {});
+			return self.getVariableInfo(name, opts);
 		},
-		getVariableInfo: function(name,opts) {
-			if($tw.utils.hop(variables,name)) {
-				return {
-					text: variables[name]
-				};
-			} else {
-				opts = opts || {};
-				opts.variables = $tw.utils.extend({},variables,opts.variables);
-				return self.getVariableInfo(name,opts);
-			};
+
+
+		getVariable(name,opts) {
+			return this.getVariableInfo(name, opts).text;
 		},
-		makeFakeWidgetWithVariables: self.makeFakeWidgetWithVariables,
+
 		resolveVariableParameters: self.resolveVariableParameters,
-		wiki: self.wiki
+		wiki: self.wiki,
+		makeFakeWidgetWithVariables: self.makeFakeWidgetWithVariables,
+
+		get variables() {
+			// Merge parent vars via prototype-like delegation
+			return Object.create(self.variables || {}, 
+				Object.keys(vars).reduce((acc, key) => {
+					acc[key] = { value: vars[key], enumerable: true, configurable: true };
+					return acc;
+				}, {})
+			);
+		}
 	};
+
+	return fakeWidget;
 };
 
 /*
 Compute the current values of the attributes of the widget. Returns a hashmap of the names of the attributes that have changed.
 Options include:
 filterFn: only include attributes where filterFn(name) returns true
+asList: boolean if true returns results as an array instead of a single value
 */
 Widget.prototype.computeAttributes = function(options) {
 	options = options || {};
 	var changedAttributes = {},
-		self = this;
+		self = this,
+		newMultiValuedAttributes = Object.create(null);
 	$tw.utils.each(this.parseTreeNode.attributes,function(attribute,name) {
 		if(options.filterFn) {
 			if(!options.filterFn(name)) {
 				return;
 			}
 		}
-		var value = self.computeAttribute(attribute);
-		if(self.attributes[name] !== value) {
+		var value = self.computeAttribute(attribute,options),
+			multiValue = null;
+		if($tw.utils.isArray(value)) {
+			multiValue = value;
+			newMultiValuedAttributes[name] = multiValue;
+			value = value[0] || "";
+		}
+		var changed = (self.attributes[name] !== value);
+		if(!changed && multiValue && self.multiValuedAttributes) {
+			changed = !$tw.utils.isArrayEqual(self.multiValuedAttributes[name] || [], multiValue);
+		}
+		if(changed) {
 			self.attributes[name] = value;
 			changedAttributes[name] = true;
 		}
 	});
+	this.multiValuedAttributes = newMultiValuedAttributes;
 	return changedAttributes;
 };
 
-Widget.prototype.computeAttribute = function(attribute) {
+/*
+Compute the value of a single attribute. Options include:
+asList: boolean if true returns results as an array instead of a single value
+*/
+Widget.prototype.computeAttribute = function(attribute,options) {
+	options = options || {};
 	var self = this,
 		value;
 	if(attribute.type === "filtered") {
-		value = this.wiki.filterTiddlers(attribute.filter,this)[0] || "";
+		value = this.wiki.filterTiddlers(attribute.filter,this);
+		if(!options.asList) {
+			value = value[0] || "";
+		}
 	} else if(attribute.type === "indirect") {
-		value = this.wiki.getTextReference(attribute.textReference,"",this.getVariable("currentTiddler")) || "";
+		value = this.wiki.getTextReference(attribute.textReference,"",this.getVariable("currentTiddler"));
+		if(value && options.asList) {
+			value = [value];
+		}
 	} else if(attribute.type === "macro") {
-		var variableInfo = this.getVariableInfo(attribute.value.name,{params: attribute.value.params});
-		value = variableInfo.text;
+		// Get the macro name
+		var macroName = attribute.value.attributes["$variable"].value;
+		// Collect macro parameters
+		var params = [];
+		$tw.utils.each(attribute.value.orderedAttributes,function(attr) {
+			var param = {
+				value: self.computeAttribute(attr)
+			};
+			if(attr.name && !attr.isPositional) {
+				param.name = attr.name;
+			}
+			params.push(param);
+		});
+		// Invoke the macro
+		var variableInfo = this.getVariableInfo(macroName,{params: params});
+		if(options.asList || attribute.isMVV) {
+			value = variableInfo.resultList;
+		} else {
+			value = variableInfo.text;
+		}
 	} else if(attribute.type === "substituted") {
 		value = this.wiki.getSubstitutedText(attribute.rawValue,this) || "";
+		if(options.asList) {
+			value = [value];
+		}
 	} else { // String attribute
 		value = attribute.value;
+		if(options.asList) {
+			if(value !== undefined) {
+				value = [value];
+			}
+		}
 	}
 	return value;
 };
@@ -530,9 +606,9 @@ Widget.prototype.makeChildWidget = function(parseTreeNode,options) {
 	var variableDefinitionName = "$" + parseTreeNode.type;
 	if(this.variables[variableDefinitionName]) {
 		var isOverrideable = function() {
-				// Widget is overrideable if its name contains a period, or if it is an existing JS widget and we're not in safe mode
-				return parseTreeNode.type.indexOf(".") !== -1 || (!!self.widgetClasses[parseTreeNode.type] && !$tw.safeMode);
-			};
+			// Widget is overrideable if its name contains a period, or if it is an existing JS widget and we're not in safe mode
+			return parseTreeNode.type.indexOf(".") !== -1 || (!!self.widgetClasses[parseTreeNode.type] && !$tw.safeMode);
+		};
 		if(!parseTreeNode.isNotRemappable && isOverrideable()) { 
 			var variableInfo = this.getVariableInfo(variableDefinitionName,{allowSelfAssigned: true});
 			if(variableInfo && variableInfo.srcVariable && variableInfo.srcVariable.value && variableInfo.srcVariable.isWidgetDefinition) {
@@ -661,7 +737,7 @@ Widget.prototype.dispatchEvent = function(event) {
 		$tw.utils.each(listeners,function(handler) {
 			var propagate;
 			if(typeof handler === "string") {
-				 // If handler is a string, call it as a method on the widget
+				// If handler is a string, call it as a method on the widget
 				propagate = self[handler].call(self,event);
 			} else {
 				// Otherwise call the function handler directly
@@ -704,7 +780,7 @@ Refresh all the children of a widget
 Widget.prototype.refreshChildren = function(changedTiddlers) {
 	var children = this.children,
 		refreshed = false;
-	for (var i = 0; i < children.length; i++) {
+	for(var i = 0; i < children.length; i++) {
 		refreshed = children[i].refresh(changedTiddlers) || refreshed;
 	}
 	return refreshed;
@@ -717,9 +793,9 @@ Widget.prototype.findNextSiblingDomNode = function(startIndex) {
 	// Refer to this widget by its index within its parents children
 	var parent = this.parentWidget,
 		index = startIndex !== undefined ? startIndex : parent.children.indexOf(this);
-if(index === -1) {
-	throw "node not found in parents children";
-}
+	if(index === -1) {
+		throw "node not found in parents children";
+	}
 	// Look for a DOM node in the later siblings
 	while(++index < parent.children.length) {
 		var domNode = parent.children[index].findFirstDomNode();
@@ -757,21 +833,60 @@ Widget.prototype.findFirstDomNode = function() {
 };
 
 /*
-Remove any DOM nodes created by this widget or its children
+Entry into destroy procedure
+options include:
+	removeDOMNodes: boolean (default true)
+*/
+Widget.prototype.destroyChildren = function(options) {
+	$tw.utils.each(this.children,function(childWidget) {
+		childWidget.destroy(options);
+	});
+};
+
+/*
+Legacy entry into destroy procedure
 */
 Widget.prototype.removeChildDomNodes = function() {
-	// If this widget has directly created DOM nodes, delete them and exit. This assumes that any child widgets are contained within the created DOM nodes, which would normally be the case
-	if(this.domNodes.length > 0) {
-		$tw.utils.each(this.domNodes,function(domNode) {
+	this.destroy({removeDOMNodes: true});
+};
+
+/*
+Default destroy
+options include:
+- removeDOMNodes: boolean (default true)
+*/
+Widget.prototype.destroy = function(options) {
+	const { removeDOMNodes = true } = options || {};
+	let removeChildDOMNodes = removeDOMNodes;
+	if(removeDOMNodes && this.domNodes.length > 0) {
+		// If this widget will remove its own DOM nodes, children should not remove theirs
+		removeChildDOMNodes = false;
+	}
+	// Destroy children first
+	this.destroyChildren({removeDOMNodes: removeChildDOMNodes});
+	this.children = [];
+	
+	// Call custom cleanup method if implemented
+	if(typeof this.onDestroy === "function") {
+		this.onDestroy();
+	}
+	
+	// Remove our DOM nodes if needed
+	if(removeDOMNodes) {
+		this.removeLocalDomNodes();	
+	}
+};
+
+/*
+Remove any DOM nodes created by this widget 
+*/
+Widget.prototype.removeLocalDomNodes = function() {
+	for(const domNode of this.domNodes) {
+		if(domNode.parentNode) {
 			domNode.parentNode.removeChild(domNode);
-		});
-		this.domNodes = [];
-	} else {
-		// Otherwise, ask the child widgets to delete their DOM nodes
-		$tw.utils.each(this.children,function(childWidget) {
-			childWidget.removeChildDomNodes();
-		});
+		}
 	}
+	this.domNodes = [];
 };
 
 /*

package/core/modules/widgets/wikify.js

@@ -42,13 +42,13 @@ WikifyWidget.prototype.execute = function() {
 	this.wikifyOutput = this.getAttribute("output","text");
 	// Create the parse tree
 	this.wikifyParser = this.wiki.parseText(this.wikifyType,this.wikifyText,{
-			parseAsInline: this.wikifyMode === "inline"
-		});
+		parseAsInline: this.wikifyMode === "inline"
+	});
 	// Create the widget tree 
 	this.wikifyWidgetNode = this.wiki.makeWidget(this.wikifyParser,{
-			document: $tw.fakeDocument,
-			parentWidget: this
-		});
+		document: $tw.fakeDocument,
+		parentWidget: this
+	});
 	// Render the widget tree to the container
 	this.wikifyContainer = $tw.fakeDocument.createElement("div");
 	this.wikifyWidgetNode.render(this.wikifyContainer,null);

package/core/modules/wiki-bulkops.js

@@ -9,6 +9,7 @@ Bulk tiddler operations such as rename.
 
 "use strict";
 
+var relinkers = $tw.modules.getModulesByTypeAsHashmap("relinker");
 /*
 Rename a tiddler, and relink any tags or lists that reference it.
 */
@@ -24,7 +25,7 @@ function renameTiddler(fromTitle,toTitle,options) {
 		this.addTiddler(newTiddler);
 		this.deleteTiddler(fromTitle);
 		// Rename any tags or lists that reference it
-		this.relinkTiddler(fromTitle,toTitle,options)
+		this.relinkTiddler(fromTitle,toTitle,options);
 	}
 }
 
@@ -32,50 +33,13 @@ function renameTiddler(fromTitle,toTitle,options) {
 Relink any tags or lists that reference a given tiddler
 */
 function relinkTiddler(fromTitle,toTitle,options) {
-	var self = this;
 	fromTitle = (fromTitle || "").trim();
 	toTitle = (toTitle || "").trim();
 	options = options || {};
 	if(fromTitle && toTitle && fromTitle !== toTitle) {
-		this.each(function(tiddler,title) {
-			var type = tiddler.fields.type || "";
-			// Don't touch plugins or JavaScript modules
-			if(!tiddler.fields["plugin-type"] && type !== "application/javascript") {
-				var tags = tiddler.fields.tags ? tiddler.fields.tags.slice(0) : undefined,
-					list = tiddler.fields.list ? tiddler.fields.list.slice(0) : undefined,
-					isModified = false,
-					processList = function(listField) {
-						if(listField && listField.indexOf(fromTitle) !== -1) {
-							// Remove any existing instances of the toTitle
-							var p = listField.indexOf(toTitle);
-							while(p !== -1) {
-								listField.splice(p,1);
-								p = listField.indexOf(toTitle);
-							}
-							// Replace the fromTitle with toTitle
-							$tw.utils.each(listField,function (title,index) {
-								if(title === fromTitle) {
-									listField[index] = toTitle;
-									isModified = true;
-								}
-							});
-						}
-					};
-				if(!options.dontRenameInTags) {
-					// Rename tags
-					processList(tags);
-				}
-				if(!options.dontRenameInLists) {
-					// Rename lists
-					processList(list);
-				}
-				if(isModified) {
-					var newTiddler = new $tw.Tiddler(tiddler,{tags: tags, list: list},self.getModificationFields())
-					newTiddler = $tw.hooks.invokeHook("th-relinking-tiddler",newTiddler,tiddler);
-					self.addTiddler(newTiddler);
-				}
-			}
-		});
+		for(var name in relinkers) {
+			relinkers[name].relink(this,fromTitle,toTitle,options);
+		}
 	}
 };