tiddlywiki 5.3.8 → 5.4.1

package/editions/test/tiddlers/tests/test-compare-filter.js

@@ -7,16 +7,13 @@ Tests the compare filter.
 
 \*/
 
-
-/* jslint node: true, browser: true */
 /* eslint-env node, browser, jasmine */
 /* eslint no-mixed-spaces-and-tabs: ["error", "smart-tabs"]*/
-/* global $tw, require */
 "use strict";
 
 describe("'compare' filter tests", function() {
 
-	var wiki = new $tw.Wiki();
+	var wiki = $tw.test.wiki();
 
 	it("should compare numerical equality", function() {
 		expect(wiki.filterTiddlers("[[2]compare:number:eq[0003]]").join(",")).toBe("");

package/editions/test/tiddlers/tests/test-deprecated.js

@@ -0,0 +1,252 @@
+/*\
+title: test-deprecated.js
+type: application/javascript
+tags: [[$:/tags/test-spec]]
+
+Regression-guard tests for $:/core/modules/utils/deprecated.js.
+
+Locks in pre-5.4.0 tolerant behaviour of $tw.utils helpers that regressed
+in PR #9251 (one-line modern equivalents diverge on edge-case inputs).
+Without the companion restoration patch to core/modules/utils/deprecated.js:
+8 specs fail. With the patch: green.
+
+The addClass/removeClass/toggleClass specs at the end were moved from
+test-utils.js — RSOD guard for the SampleWizard report (class field
+"aaa bbb" crashing classList.add with InvalidCharacterError).
+
+\*/
+
+"use strict";
+
+describe("deprecated.js — backwards-compat",function() {
+
+	describe("$tw.utils.repeat",function() {
+		it("returns '' for zero or negative count (does not throw)",function() {
+			expect($tw.utils.repeat("x",0)).toBe("");
+			expect($tw.utils.repeat("x",-1)).toBe("");
+			expect($tw.utils.repeat("x",-100)).toBe("");
+		});
+		it("coerces null/undefined str rather than throwing",function() {
+			expect($tw.utils.repeat(null,3)).toBe("nullnullnull");
+			expect($tw.utils.repeat(undefined,2)).toBe("undefinedundefined");
+		});
+		it("still works for normal inputs",function() {
+			expect($tw.utils.repeat("ab",3)).toBe("ababab");
+			expect($tw.utils.repeat("-",5)).toBe("-----");
+		});
+	});
+
+	describe("$tw.utils.startsWith / $tw.utils.endsWith",function() {
+		it("tolerate a RegExp search argument without throwing",function() {
+			// Old impl uses substring coercion; native String.prototype.startsWith
+			// throws TypeError when passed a RegExp.
+			expect(function() { $tw.utils.startsWith("abc",/a/); }).not.toThrow();
+			expect(function() { $tw.utils.endsWith("abc",/c/); }).not.toThrow();
+		});
+		it("still match normal string inputs",function() {
+			expect($tw.utils.startsWith("abcdef","abc")).toBe(true);
+			expect($tw.utils.startsWith("abcdef","xyz")).toBe(false);
+			expect($tw.utils.endsWith("abcdef","def")).toBe(true);
+			expect($tw.utils.endsWith("abcdef","xyz")).toBe(false);
+		});
+	});
+
+	describe("$tw.utils.stringifyNumber",function() {
+		it("coerces null/undefined via string-concat rather than throwing",function() {
+			expect($tw.utils.stringifyNumber(null)).toBe("null");
+			expect($tw.utils.stringifyNumber(undefined)).toBe("undefined");
+		});
+		it("still returns a number's string form",function() {
+			expect($tw.utils.stringifyNumber(42)).toBe("42");
+			expect($tw.utils.stringifyNumber(-3.14)).toBe("-3.14");
+			expect($tw.utils.stringifyNumber(0)).toBe("0");
+		});
+	});
+
+	describe("$tw.utils.domContains",function() {
+		// Stub nodes expose both .contains() and .compareDocumentPosition() so
+		// both the old (compareDocumentPosition & 16 → number) and new
+		// (a !== b && a.contains(b) → boolean) forms can be observed.
+		function makeNode(children) {
+			children = children || [];
+			var self;
+			self = {
+				contains: function(other) {
+					if(other === self) { return true; }
+					return children.some(function(c) { return c === other || c.contains(other); });
+				},
+				compareDocumentPosition: function(other) {
+					if(other === self) { return 0; }
+					return self.contains(other) ? 16 : 0;
+				}
+			};
+			return self;
+		}
+		it("returns strictly boolean true/false, not a bit-mask number",function() {
+			var child = makeNode();
+			var parent = makeNode([child]);
+			var unrelated = makeNode();
+			expect($tw.utils.domContains(parent,child)).toBe(true);
+			expect($tw.utils.domContains(parent,unrelated)).toBe(false);
+		});
+		it("returns false for domContains(x, x)",function() {
+			var a = makeNode();
+			expect($tw.utils.domContains(a,a)).toBe(false);
+		});
+	});
+
+	describe("$tw.utils.hasClass",function() {
+		it("returns false for null/undefined element without throwing",function() {
+			expect(function() { $tw.utils.hasClass(null,"foo"); }).not.toThrow();
+			expect($tw.utils.hasClass(null,"foo")).toBe(false);
+			expect(function() { $tw.utils.hasClass(undefined,"foo"); }).not.toThrow();
+			expect($tw.utils.hasClass(undefined,"foo")).toBe(false);
+		});
+		it("returns strictly false (not undefined) for elements without classList",function() {
+			expect($tw.utils.hasClass({},"foo")).toBe(false);
+		});
+		it("delegates to classList.contains for real elements",function() {
+			var el = { classList: { contains: function(c) { return c === "a" || c === "b"; } } };
+			expect($tw.utils.hasClass(el,"a")).toBe(true);
+			expect($tw.utils.hasClass(el,"b")).toBe(true);
+			expect($tw.utils.hasClass(el,"c")).toBe(false);
+		});
+	});
+
+	// getLocationPath reads window.location: specs pend in Node (no `window`
+	// in the TW5 sandbox) and use history.replaceState in the browser —
+	// assigning to window.location would trigger a navigation and reload.
+	describe("$tw.utils.getLocationPath",function() {
+		var originalUrl;
+		beforeEach(function() {
+			if(!$tw.browser) { return; }
+			originalUrl = window.location.href;
+		});
+		afterEach(function() {
+			if(!$tw.browser) { return; }
+			history.replaceState(null,"",originalUrl);
+		});
+		it("preserves the query string in the returned path",function() {
+			if(!$tw.browser) { pending("browser-only: requires window.location - run in browser"); return; }
+			history.replaceState(null,"","?lang=de&x=1#Intro");
+			var path = $tw.utils.getLocationPath();
+			expect(path).toContain("?lang=de&x=1");
+			expect(path).not.toContain("#Intro");
+		});
+		it("strips the hash fragment",function() {
+			if(!$tw.browser) { pending("browser-only: requires window.location - run in browser"); return; }
+			history.replaceState(null,"","#SomeTiddler");
+			// Sanity check: replaceState actually changed the hash.
+			expect(window.location.hash).toBe("#SomeTiddler");
+			var path = $tw.utils.getLocationPath();
+			expect(path).not.toContain("#");
+			// Rebuild expected href without the hash — works on http(s):// and file://.
+			var expected = window.location.href.split("#")[0];
+			expect(path).toBe(expected);
+		});
+		it("includes the query string when no hash is present",function() {
+			if(!$tw.browser) { pending("browser-only: requires window.location - run in browser"); return; }
+			history.replaceState(null,"","?x=1");
+			var path = $tw.utils.getLocationPath();
+			expect(path).toMatch(/\?x=1$/);
+			expect(path).not.toContain("#");
+		});
+	});
+
+	// Regression guard: classList.add/remove/toggle throw InvalidCharacterError on
+	// whitespace. Manual repro: tw5-com #SampleWizard, class="aaa bbb", Done, popup
+	// -> OK -> nested popup -> RSOD. Stub classList mirrors real DOM semantics
+	// (reject whitespace, de-dupe on add, no-op on remove of missing token).
+	describe("addClass/removeClass/toggleClass",function() {
+		function makeEl() {
+			var tokens = [];
+			function reject(t) { if(/\s/.test(t)) { throw new Error("InvalidCharacterError: '" + t + "'"); } }
+			return {
+				classList: {
+					add: function() {
+						for(var i = 0; i < arguments.length; i++) {
+							reject(arguments[i]);
+							if(tokens.indexOf(arguments[i]) === -1) { tokens.push(arguments[i]); }
+						}
+					},
+					remove: function() {
+						for(var i = 0; i < arguments.length; i++) {
+							reject(arguments[i]);
+							var idx = tokens.indexOf(arguments[i]);
+							if(idx !== -1) { tokens.splice(idx,1); }
+						}
+					},
+					toggle: function(cls,status) {
+						reject(cls);
+						var has = tokens.indexOf(cls) !== -1;
+						var want = status === undefined ? !has : status;
+						if(want && !has) { tokens.push(cls); }
+						if(!want && has) { tokens.splice(tokens.indexOf(cls),1); }
+					}
+				},
+				_tokens: tokens
+			};
+		}
+
+		it("splits on every ASCII-whitespace flavour (space, tab, newline, CR, mixed runs, leading/trailing)",function() {
+			var el = makeEl();
+			$tw.utils.addClass(el,"  a\tb\nc\r\nd  \t  e  ");
+			expect(el._tokens).toEqual(["a","b","c","d","e"]);
+		});
+
+		it("splits on Unicode whitespace too (U+00A0 non-breaking space, a common paste-in hazard)",function() {
+			var el = makeEl();
+			$tw.utils.addClass(el,"a\u00A0b");
+			expect(el._tokens).toEqual(["a","b"]);
+		});
+
+		it("de-duplicates tokens within one call and across calls",function() {
+			var el = makeEl();
+			$tw.utils.addClass(el,"x x y");
+			$tw.utils.addClass(el,"y z");
+			expect(el._tokens).toEqual(["x","y","z"]);
+		});
+
+		it("remove is a no-op for missing tokens and tolerates mixed-presence input",function() {
+			var el = makeEl();
+			$tw.utils.addClass(el,"a b");
+			$tw.utils.removeClass(el,"b c d");
+			expect(el._tokens).toEqual(["a"]);
+		});
+
+		it("toggle with no status flips each token independently",function() {
+			var el = makeEl();
+			$tw.utils.addClass(el,"a");
+			$tw.utils.toggleClass(el,"a b");
+			expect(el._tokens).toEqual(["b"]);
+		});
+
+		it("toggle with status=true/false forces state regardless of current",function() {
+			var el = makeEl();
+			$tw.utils.addClass(el,"a");
+			$tw.utils.toggleClass(el,"a b",true);
+			expect(el._tokens).toEqual(["a","b"]);
+			$tw.utils.toggleClass(el,"a b",false);
+			expect(el._tokens).toEqual([]);
+		});
+
+		it("is a silent no-op for whitespace-only / empty / non-string / null / undefined className",function() {
+			var el = makeEl();
+			var inputs = ["", "   \t\n ", null, undefined, 42, {}, ["a"]];
+			inputs.forEach(function(v) {
+				expect(function() { $tw.utils.addClass(el,v); }).not.toThrow();
+				expect(function() { $tw.utils.removeClass(el,v); }).not.toThrow();
+				expect(function() { $tw.utils.toggleClass(el,v); }).not.toThrow();
+			});
+			expect(el._tokens).toEqual([]);
+		});
+
+		it("is a silent no-op when element has no classList (SVG in old browsers, detached nodes, stubs)",function() {
+			var el = {};
+			expect(function() { $tw.utils.addClass(el,"a b"); }).not.toThrow();
+			expect(function() { $tw.utils.removeClass(el,"a b"); }).not.toThrow();
+			expect(function() { $tw.utils.toggleClass(el,"a b",true); }).not.toThrow();
+		});
+	});
+
+});

package/editions/test/tiddlers/tests/test-deserialize-operator.js

@@ -7,34 +7,31 @@ Tests deserialize[] filter operator with various core deserializers
 
 \*/
 
-
-	/* jslint node: true, browser: true */
-	/* eslint-env node, browser, jasmine */
-	/* eslint no-mixed-spaces-and-tabs: ["error", "smart-tabs"]*/
-	/* global $tw, require */
-	"use strict";
+/* eslint-env node, browser, jasmine */
+/* eslint no-mixed-spaces-and-tabs: ["error", "smart-tabs"]*/
+"use strict";
 
 	
-	describe("deserialize operator tests", function() {
+describe("deserialize operator tests", function() {
 
-		it("should support the deserialize[] operator", function() {
-			//Unknown deserializer as operand
-			expect($tw.wiki.filterTiddlers("[{dezerializer test data case 4}deserialize[unknown/deserializer]]")).toEqual([$tw.language.getString("Error/DeserializeOperator/UnknownDeserializer")]);
+	it("should support the deserialize[] operator", function() {
+		//Unknown deserializer as operand
+		expect($tw.wiki.filterTiddlers("[{dezerializer test data case 4}deserialize[unknown/deserializer]]")).toEqual([$tw.language.getString("Error/DeserializeOperator/UnknownDeserializer")]);
 
-			//Missing operand
-			expect($tw.wiki.filterTiddlers("[{dezerializer test data case 4}deserialize[]]")).toEqual([$tw.language.getString("Error/DeserializeOperator/MissingOperand")]);
+		//Missing operand
+		expect($tw.wiki.filterTiddlers("[{dezerializer test data case 4}deserialize[]]")).toEqual([$tw.language.getString("Error/DeserializeOperator/MissingOperand")]);
 
-			//Deserialize TiddlyWiki file
-			expect($tw.wiki.filterTiddlers("[{dezerializer test data case 4}deserialize[text/html]]")).toEqual(['[{"type":"text/vnd.tiddlywiki","text":"Abacus","title":"Hello \\"There\\""},{"title":"Hello \\"There\\"","text":"Calculator"}]']);
-			expect($tw.wiki.filterTiddlers("[{dezerializer test data case 5}deserialize[text/html]]")).toEqual(['[{"type":"text/vnd.tiddlywiki","text":"Abacus","title":"Hello \\"There\\""},{"title":"Hello \\"There\\"","text":"Calculator"},{"title":"Hello \\"There\\"","text":"Protractor"}]']);
+		//Deserialize TiddlyWiki file
+		expect($tw.wiki.filterTiddlers("[{dezerializer test data case 4}deserialize[text/html]]")).toEqual(['[{"type":"text/vnd.tiddlywiki","text":"Abacus","title":"Hello \\"There\\""},{"title":"Hello \\"There\\"","text":"Calculator"}]']);
+		expect($tw.wiki.filterTiddlers("[{dezerializer test data case 5}deserialize[text/html]]")).toEqual(['[{"type":"text/vnd.tiddlywiki","text":"Abacus","title":"Hello \\"There\\""},{"title":"Hello \\"There\\"","text":"Calculator"},{"title":"Hello \\"There\\"","text":"Protractor"}]']);
 
-			// Deserialize JSON payload containing tiddlers
-			expect($tw.wiki.filterTiddlers("[{dezerializer test data case 6}deserialize[application/json]]")).toEqual( [ `[{"created":"20230601125557184","text":"Before you start storing important information in ~TiddlyWiki it is vital to make sure that you can reliably save changes. See https://tiddlywiki.com/#GettingStarted for details\\n\\n","title":"GettingStarted","modified":"20230601125601619"},{"created":"20230601125507054","text":"Welcome to \\"TiddlyWiki\\".\\n\\nThis is a test tiddler.","tags":"","title":"Hello There \\"Welcome\\"","modified":"20230601125551144"},{"title":"TiddlyWiki","created":"20130822170700000","modified":"20170127221451610","tags":"Concepts","type":"text/vnd.tiddlywiki","text":"~TiddlyWiki is a rich, interactive tool for manipulating complex data with structure that doesn't easily fit into conventional tools like spreadsheets or wordprocessors.\\n\\n~TiddlyWiki is designed to fit around your brain, helping you deal with the things that won't fit."}]` ]);
-			expect($tw.wiki.filterTiddlers("[{dezerializer test data case 6}deserialize[application/json]jsonindexes[]] :map[{dezerializer test data case 6}jsonget<currentTiddler>,[title]]")).toEqual([ 'GettingStarted', 'Hello There "Welcome"', 'TiddlyWiki' ]);
+		// Deserialize JSON payload containing tiddlers
+		expect($tw.wiki.filterTiddlers("[{dezerializer test data case 6}deserialize[application/json]]")).toEqual( [ "[{\"created\":\"20230601125557184\",\"text\":\"Before you start storing important information in ~TiddlyWiki it is vital to make sure that you can reliably save changes. See https://tiddlywiki.com/#GettingStarted for details\\n\\n\",\"title\":\"GettingStarted\",\"modified\":\"20230601125601619\"},{\"created\":\"20230601125507054\",\"text\":\"Welcome to \\\"TiddlyWiki\\\".\\n\\nThis is a test tiddler.\",\"tags\":\"\",\"title\":\"Hello There \\\"Welcome\\\"\",\"modified\":\"20230601125551144\"},{\"title\":\"TiddlyWiki\",\"created\":\"20130822170700000\",\"modified\":\"20170127221451610\",\"tags\":\"Concepts\",\"type\":\"text/vnd.tiddlywiki\",\"text\":\"~TiddlyWiki is a rich, interactive tool for manipulating complex data with structure that doesn't easily fit into conventional tools like spreadsheets or wordprocessors.\\n\\n~TiddlyWiki is designed to fit around your brain, helping you deal with the things that won't fit.\"}]" ]);
+		expect($tw.wiki.filterTiddlers("[{dezerializer test data case 6}deserialize[application/json]jsonindexes[]] :map[{dezerializer test data case 6}jsonget<currentTiddler>,[title]]")).toEqual([ "GettingStarted", 'Hello There "Welcome"', "TiddlyWiki" ]);
 
-			//Deserialize TiddlyWiki file with an mismatched deserializer
-			expect($tw.wiki.filterTiddlers("[{dezerializer test data case 5}deserialize[application/json]]")).toEqual([jasmine.stringMatching('JSON error')]);
-		});
+		//Deserialize TiddlyWiki file with an mismatched deserializer
+		expect($tw.wiki.filterTiddlers("[{dezerializer test data case 5}deserialize[application/json]]")).toEqual([jasmine.stringMatching("JSON error")]);
 	});
+});
 	
 

package/editions/test/tiddlers/tests/test-deserializers.js

@@ -7,29 +7,27 @@ Tests various core deserializers
 
 \*/
 
-	/* jslint node: true, browser: true */
-	/* eslint-env node, browser, jasmine */
-	/* eslint no-mixed-spaces-and-tabs: ["error", "smart-tabs"]*/
-	/* global $tw, require */
-	"use strict";
+/* eslint-env node, browser, jasmine */
+/* eslint no-mixed-spaces-and-tabs: ["error", "smart-tabs"]*/
+"use strict";
 	
-	describe("deserializer tests", function() {
-
-		function executeTestCase(title,expectedOutput) {
-			it("test case " + title, function() {
-				var tiddler = $tw.wiki.getTiddler(title);
-				expect($tw.wiki.deserializeTiddlers(tiddler.fields.type,tiddler.fields.text)).toEqual(expectedOutput);
-			});
-		}
+describe("deserializer tests", function() {
+
+	function executeTestCase(title,expectedOutput) {
+		it("test case " + title, function() {
+			var tiddler = $tw.wiki.getTiddler(title);
+			expect($tw.wiki.deserializeTiddlers(tiddler.fields.type,tiddler.fields.text)).toEqual(expectedOutput);
+		});
+	}
 	
-		executeTestCase("dezerializer test data case 1",[ { text: '<!doctype html>\n', type: 'text/html' } ]);
+	executeTestCase("dezerializer test data case 1",[ { text: "<!doctype html>\n", type: "text/html" } ]);
 
-		executeTestCase("dezerializer test data case 2",[ { text: '<!doctype html>\n<html lang="en">\n<head>\n\t<meta charset="utf-8">\n\t<title>Test Data</title>\n</head>\n<body>\n</body>\n</html>\n', type: 'text/html' } ]);
+	executeTestCase("dezerializer test data case 2",[ { text: '<!doctype html>\n<html lang="en">\n<head>\n\t<meta charset="utf-8">\n\t<title>Test Data</title>\n</head>\n<body>\n</body>\n</html>\n', type: "text/html" } ]);
 
-		executeTestCase("dezerializer test data case 3",[ { title: 'Hello "There"', text: 'Abacus', type: 'text/vnd.tiddlywiki' } ]);
+	executeTestCase("dezerializer test data case 3",[ { title: 'Hello "There"', text: "Abacus", type: "text/vnd.tiddlywiki" } ]);
 
-		executeTestCase("dezerializer test data case 4",[ { title: 'Hello "There"', text: 'Abacus', type: 'text/vnd.tiddlywiki' }, { title: 'Hello "There"', text: 'Calculator'}  ]);
+	executeTestCase("dezerializer test data case 4",[ { title: 'Hello "There"', text: "Abacus", type: "text/vnd.tiddlywiki" }, { title: 'Hello "There"', text: "Calculator"}  ]);
 
-		executeTestCase("dezerializer test data case 5",[ { title: 'Hello "There"', text: 'Abacus', type: 'text/vnd.tiddlywiki' }, { title: 'Hello "There"', text: 'Calculator'} , { title: 'Hello "There"', text: 'Protractor'}  ]);
+	executeTestCase("dezerializer test data case 5",[ { title: 'Hello "There"', text: "Abacus", type: "text/vnd.tiddlywiki" }, { title: 'Hello "There"', text: "Calculator"} , { title: 'Hello "There"', text: "Protractor"}  ]);
 		
-	});
+});

package/editions/test/tiddlers/tests/test-edit-widgets/edit-widgets-helpers.js

@@ -0,0 +1,138 @@
+/*\
+title: $:/tests/test-edit-widgets/helpers
+type: application/javascript
+module-type: library
+
+Shared test helpers for the edit-text / edit-widget test suite. Every
+helper here is usable in fakedom — nothing reaches for real DOM layout,
+iframe documents, or synthetic events.
+
+Import with:
+
+    var helpers = require("$:/tests/test-edit-widgets/helpers");
+
+\*/
+
+"use strict";
+
+var widget = require("$:/core/modules/widgets/widget.js");
+
+/*
+makeWiki: build a fresh in-memory test wiki. Pass an array of tiddler
+specs to seed. Use `seedTestTiddler: true` in the options to also add a
+convenience "TestTiddler" (empty text) that many tests default to.
+*/
+exports.makeWiki = function(tiddlers,options) {
+	options = options || {};
+	var wiki = $tw.test.wiki();
+	if(options.seedTestTiddler) {
+		wiki.addTiddlers([{title: "TestTiddler", text: ""}]);
+	}
+	if(tiddlers) {
+		wiki.addTiddlers(tiddlers);
+	}
+	return wiki;
+};
+
+/*
+parseAndRender: parse a wikitext snippet, build the widget tree against
+the fakedom, and render into a detached wrapper <div>. Returns both the
+top-level widgetNode (for refresh/teardown) and the wrapper (for DOM
+inspection).
+*/
+exports.parseAndRender = function(widgetText,wiki) {
+	var parser = wiki.parseText("text/vnd.tiddlywiki",widgetText);
+	var widgetNode = new widget.widget(
+		{type: "widget", children: parser.tree},
+		{wiki: wiki, document: $tw.fakeDocument}
+	);
+	$tw.fakeDocument.setSequenceNumber(0);
+	var wrapper = $tw.fakeDocument.createElement("div");
+	widgetNode.render(wrapper,null);
+	return {widgetNode: widgetNode, wrapper: wrapper};
+};
+
+/*
+findEditTextWidget: walk a widget tree and return the first
+EditTextWidget instance (identified by having both an `engine` and an
+`editTag` property). Needed because parseAndRender returns the
+enclosing "widget" root, not the <$edit-text> itself.
+*/
+exports.findEditTextWidget = function findEditTextWidget(node) {
+	if(node.engine && node.editTag !== undefined) {
+		return node;
+	}
+	if(node.children) {
+		for(var i = 0; i < node.children.length; i++) {
+			var found = findEditTextWidget(node.children[i]);
+			if(found) return found;
+		}
+	}
+	return null;
+};
+
+/*
+renderFromWikitext: parse+render a wikitext snippet and return a bundle
+{ widget, root, wrapper, wiki } exposing every layer. Used by the
+attribute-propagation and refresh tests which need access to the wiki
+and wrapper after render.
+*/
+exports.renderFromWikitext = function(widgetText,wiki) {
+	wiki = wiki || exports.makeWiki([{title: "TestTiddler", text: "hello"}]);
+	var result = exports.parseAndRender(widgetText,wiki);
+	return {
+		widget: exports.findEditTextWidget(result.widgetNode),
+		root: result.widgetNode,
+		wrapper: result.wrapper,
+		wiki: wiki
+	};
+};
+
+/*
+renderFromAttrs: build an <$edit-text> tag from an attrs object, render
+it, and return just the EditTextWidget instance (not a full bundle).
+Used by tests that only need the widget and its DOM node.
+*/
+exports.renderFromAttrs = function(attrs,wiki,tiddlerTitle) {
+	wiki = wiki || exports.makeWiki(null,{seedTestTiddler: true});
+	var attrStr = Object.keys(attrs).map(function(k) {
+		return k + "=\"" + attrs[k] + "\"";
+	}).join(" ");
+	var text = "<$edit-text tiddler=\"" + (tiddlerTitle || "TestTiddler") + "\" " + attrStr + "/>";
+	var rendered = exports.parseAndRender(text,wiki);
+	return exports.findEditTextWidget(rendered.widgetNode);
+};
+
+/*
+refresh: drive a widget-tree refresh cycle for a given list of changed
+tiddler titles, mimicking what the core does after wiki.addTiddler.
+*/
+exports.refresh = function(rootWidget,wrapper,changedTitles) {
+	var changed = {};
+	(changedTitles || []).forEach(function(t) { changed[t] = true; });
+	rootWidget.refresh(changed,wrapper,null);
+};
+
+/*
+editorValue: read the editor's current text in a way that works with
+fakedom. SimpleEngine seeds a textarea by appending a text-node child,
+while inputs use the `value` attribute. Later updates go through
+updateDomNodeText which sets `.value` on both.
+*/
+exports.editorValue = function(w) {
+	var dn = w.engine.domNode;
+	// If .value has been set explicitly, prefer it (covers refresh updates)
+	if(dn.attributes && dn.attributes.value !== undefined) {
+		return dn.value;
+	}
+	// Otherwise for textareas read the concatenated child text nodes
+	if(dn.tag === "textarea" && dn.children && dn.children.length) {
+		return dn.children.map(function(n) { return n.textContent || ""; }).join("");
+	}
+	return dn.value;
+};
+
+// Note: jasmine-specific helpers (spies) belong in the test-spec files
+// themselves. TW library modules run in a sandbox that does not expose
+// `jasmine`, so anything that calls jasmine.createSpy must live in a
+// file tagged with $:/tags/test-spec.