tiddlywiki 5.3.8 → 5.4.1

package/editions/test/tiddlers/tests/test-edit-widgets/test-edit-text-widget-attributes.js

@@ -0,0 +1,353 @@
+/*\
+title: test-edit-text-widget-attributes.js
+type: application/javascript
+tags: [[$:/tags/test-spec]]
+
+Covers edit-text widget behaviour that is observable in fakedom: value
+resolution, tag/type selection, DOM attribute propagation, save-back
+and refresh paths.
+
+Each spec has a "manual:" comment with a by-hand recipe so a reviewer
+can sanity-check the test against a live wiki.
+
+NOT covered (need a real browser — Playwright territory):
+* `focus`, `focusSelectFromStart`/`End`, `focusPopup`, `cancelPopups` — real DOM focus + selection APIs
+* `inputActions`, `fileDrop` — synthetic events not dispatched by fakedom
+* Pixel measurement / growth of auto-height textareas — `$tw.utils.resizeTextAreaToFit` needs real layout
+* FramedEngine — requires a real iframe document
+
+\*/
+
+"use strict";
+
+describe("Edit-text widget (attribute propagation and value handling)", function() {
+
+	// Shared helpers live in $:/tests/test-edit-widgets/helpers. See that
+	// file for what each helper prepares and where it is used across the suite.
+	var helpers = require("$:/tests/test-edit-widgets/helpers");
+
+	// Local aliases — `render`, `editorValue` etc. read better inline
+	// than `helpers.renderFromWikitext`. Each test supplies its own
+	// tiddlers, so makeWiki is NOT seeded with TestTiddler here.
+	var makeWiki = helpers.makeWiki;
+	var render = helpers.renderFromWikitext;
+	var refresh = helpers.refresh;
+	var editorValue = helpers.editorValue;
+	var findEditTextWidget = helpers.findEditTextWidget;
+
+	// spyOnSetText stays file-local because it depends on `jasmine`,
+	// which is only in scope for $:/tags/test-spec modules — NOT for
+	// library modules loaded via require().
+	function spyOnSetText(w) {
+		var spy = jasmine.createSpy("setText");
+		w.engine.setText = spy;
+		return spy;
+	}
+
+	// ---------------------------------------------------------------
+	// Value and type resolution (getEditInfo)
+	// ---------------------------------------------------------------
+
+	describe("value and type resolution", function() {
+
+		// manual: create tiddler "TestTiddler" with text "hello", then in any
+		// tiddler render <$edit-text tiddler='TestTiddler'/> — the
+		// textarea should show "hello".
+		it("reads the text field of an existing tiddler", function() {
+			var w = render("<$edit-text tiddler=\"TestTiddler\"/>");
+			expect(editorValue(w.widget)).toBe("hello");
+		});
+
+		// manual: give a tiddler "T" a caption="Hi" field, then render
+		// <$edit-text tiddler="T" field="caption"/> — input should show "Hi".
+		it("reads an arbitrary named field", function() {
+			var wiki = makeWiki([{title: "T", text: "body", caption: "Hi"}]);
+			var w = render("<$edit-text tiddler=\"T\" field=\"caption\"/>",wiki);
+			expect(editorValue(w.widget)).toBe("Hi");
+		});
+
+		// manual: create tiddler "T" without a caption field, then render
+		// <$edit-text tiddler="T" field="caption" default="fallback"/> —
+		// input should show "fallback".
+		it("falls back to the default attribute when the field is missing", function() {
+			var wiki = makeWiki([{title: "T", text: "body"}]);
+			var w = render("<$edit-text tiddler=\"T\" field=\"caption\" default=\"fallback\"/>",wiki);
+			expect(editorValue(w.widget)).toBe("fallback");
+		});
+
+		// manual: create tiddler "T" without a caption field, render
+		// <$edit-text tiddler="T" field="caption"/> — input should be empty.
+		it("falls back to an empty string when neither field nor default is present", function() {
+			var wiki = makeWiki([{title: "T", text: "body"}]);
+			var w = render("<$edit-text tiddler=\"T\" field=\"caption\"/>",wiki);
+			expect(editorValue(w.widget)).toBe("");
+		});
+
+		// manual: ensure NO tiddler named "Missing" exists, then render
+		// <$edit-text tiddler="Missing" field="title"/> — input should show
+		// "Missing" (the title field of a not-yet-existing tiddler defaults
+		// to the tiddler title).
+		it("uses the tiddler title as the default for the title field on missing tiddlers", function() {
+			var wiki = makeWiki();
+			var w = render("<$edit-text tiddler=\"Missing\" field=\"title\"/>",wiki);
+			expect(editorValue(w.widget)).toBe("Missing");
+		});
+
+		// manual: ensure NO tiddler named "Missing" exists, then render
+		// <$edit-text tiddler="Missing" default="seed"/> — textarea should
+		// show "seed" until you type into it.
+		it("uses default= on a missing tiddler", function() {
+			var wiki = makeWiki();
+			var w = render("<$edit-text tiddler=\"Missing\" default=\"seed\"/>",wiki);
+			expect(editorValue(w.widget)).toBe("seed");
+		});
+
+		// manual: create a data tiddler "Data" with type
+		// "application/x-tiddler-dictionary" and text "one: 1\ntwo: 2",
+		// then render <$edit-text tiddler="Data" index="two"/> — input
+		// should show "2".
+		it("reads a value from a data tiddler index", function() {
+			var wiki = makeWiki([
+				{title: "Data", type: "application/x-tiddler-dictionary", text: "one: 1\ntwo: 2"}
+			]);
+			var w = render("<$edit-text tiddler=\"Data\" index=\"two\"/>",wiki);
+			expect(editorValue(w.widget)).toBe("2");
+		});
+
+		// manual: with the same "Data" dictionary but no "missing" key,
+		// render <$edit-text tiddler="Data" index="missing" default="none"/> —
+		// input should show "none".
+		it("uses default= for a missing index", function() {
+			var wiki = makeWiki([
+				{title: "Data", type: "application/x-tiddler-dictionary", text: "one: 1"}
+			]);
+			var w = render("<$edit-text tiddler=\"Data\" index=\"missing\" default=\"none\"/>",wiki);
+			expect(editorValue(w.widget)).toBe("none");
+		});
+	});
+
+	// ---------------------------------------------------------------
+	// Tag and type selection
+	// ---------------------------------------------------------------
+
+	describe("tag and type selection", function() {
+
+		// manual: render <$edit-text tiddler="TestTiddler"/> and inspect the
+		// element — it should be a <textarea>.
+		it("defaults to a textarea for the text field", function() {
+			var w = render("<$edit-text tiddler=\"TestTiddler\"/>");
+			expect(w.widget.engine.domNode.tag).toBe("textarea");
+		});
+
+		// manual: render <$edit-text tiddler="TestTiddler" field="caption"/>
+		// and inspect the element — it should be a single-line <input>.
+		it("defaults to an input for non-text fields", function() {
+			var w = render("<$edit-text tiddler=\"TestTiddler\" field=\"caption\"/>");
+			expect(w.widget.engine.domNode.tag).toBe("input");
+		});
+
+		// manual: render <$edit-text tiddler="TestTiddler" tag="input"/> —
+		// even though the default for the text field is textarea, this
+		// should render as a single-line <input>.
+		it("tag=input forces an input even for the text field", function() {
+			var w = render("<$edit-text tiddler=\"TestTiddler\" tag=\"input\"/>");
+			expect(w.widget.engine.domNode.tag).toBe("input");
+		});
+
+		// manual: render <$edit-text tiddler="T" tag="input" type="password"/>
+		// — the element should be a password input (characters masked as dots).
+		it("type= sets the input type attribute", function() {
+			var w = render("<$edit-text tiddler=\"TestTiddler\" tag=\"input\" type=\"password\"/>");
+			expect(w.widget.engine.domNode.getAttribute("type")).toBe("password");
+		});
+
+		// manual: render <$edit-text tiddler="T" type="password"/> (no tag
+		// override) — the element should be a plain textarea; type is
+		// silently ignored because HTML textareas have no type attribute.
+		it("type= is ignored for textareas (no type attribute on textarea)", function() {
+			var w = render("<$edit-text tiddler=\"TestTiddler\" type=\"password\"/>");
+			expect(w.widget.engine.domNode.getAttribute("type")).toBeUndefined();
+		});
+
+		// manual: render <$edit-text tiddler="T" tag="script"/> — must NOT
+		// inject a <script> element; tag should fall back to <input>. This
+		// is a defence-in-depth check against wiki-authored HTML injection.
+		it("unsafe tag names collapse to input", function() {
+			var w = render("<$edit-text tiddler=\"TestTiddler\" tag=\"script\"/>");
+			expect(w.widget.engine.domNode.tag).toBe("input");
+		});
+	});
+
+	// ---------------------------------------------------------------
+	// DOM attribute propagation
+	// ---------------------------------------------------------------
+
+	describe("DOM attribute propagation", function() {
+
+		// manual: render <$edit-text tiddler="TestTiddler" tag="input"
+		// class="my-class" placeholder="Type here" size="40" tabindex="3"
+		// autocomplete="email" disabled="yes"/> — inspect the element in
+		// devtools; every attribute set on the widget should appear on
+		// the DOM element with the expected value. disabled="no" would
+		// omit the attribute entirely.
+		//
+		// INFO: View as "raw HTML" in preview panel
+		//
+		// SimpleEngine has one independent `if(this.widget.editXxx)
+		// setAttribute(...)` block per attribute. This combined test
+		// exercises every such block in one shot; if any copy breaks,
+		// this spec fails and the jasmine expectation report identifies
+		// the offending attribute.
+		it("copies class, placeholder, size, tabindex, autocomplete and disabled onto the DOM element", function() {
+			var w = render(
+				"<$edit-text tiddler=\"TestTiddler\" tag=\"input\" " +
+				"class=\"my-class\" placeholder=\"Type here\" size=\"40\" " +
+				"tabindex=\"3\" autocomplete=\"email\" disabled=\"yes\"/>"
+			);
+			var dn = w.widget.engine.domNode;
+			expect(dn.className).toBe("my-class");
+			expect(dn.getAttribute("placeholder")).toBe("Type here");
+			expect(dn.getAttribute("size")).toBe("40");
+			expect(dn.getAttribute("tabindex")).toBe("3");
+			expect(dn.getAttribute("autocomplete")).toBe("email");
+			expect(dn.getAttribute("disabled")).toBe("true");
+		});
+
+	});
+
+	// ---------------------------------------------------------------
+	// Save-back via saveChanges
+	// ---------------------------------------------------------------
+
+	describe("saving changes back to the store", function() {
+
+		// manual: with tiddler "T" text="old", render <$edit-text tiddler="T"/>
+		// and type "new text"; open T from the sidebar — its text field
+		// should update live.
+		it("writes a new value to the configured text field", function() {
+			var wiki = makeWiki([{title: "T", text: "old"}]);
+			var w = render("<$edit-text tiddler=\"T\"/>",wiki);
+			w.widget.saveChanges("new text");
+			expect(wiki.getTiddler("T").fields.text).toBe("new text");
+		});
+
+		// manual: with tiddler "T" caption="old", render
+		// <$edit-text tiddler="T" field="caption"/> and type a new caption;
+		// {{T!!caption}} elsewhere should update live.
+		it("writes to a non-text field", function() {
+			var wiki = makeWiki([{title: "T", text: "body", caption: "old"}]);
+			var w = render("<$edit-text tiddler=\"T\" field=\"caption\"/>",wiki);
+			w.widget.saveChanges("new caption");
+			expect(wiki.getTiddler("T").fields.caption).toBe("new caption");
+		});
+
+		// manual: ensure no tiddler "NewOne" exists, render
+		// <$edit-text tiddler="NewOne" default=""/> and type "created" —
+		// a new tiddler "NewOne" should appear in the sidebar with that
+		// text.
+		it("creates the tiddler if it does not exist", function() {
+			var wiki = makeWiki();
+			var w = render("<$edit-text tiddler=\"NewOne\" default=\"\"/>",wiki);
+			w.widget.saveChanges("created");
+			expect(wiki.tiddlerExists("NewOne")).toBe(true);
+			expect(wiki.getTiddler("NewOne").fields.text).toBe("created");
+		});
+
+		// manual: with dictionary tiddler "Data" containing one:1, two:2,
+		// render <$edit-text tiddler="Data" index="one"/> and change the
+		// value to "uno"; view Data as text — it should now read
+		// "one: uno\ntwo: 2".
+		it("writes to a data tiddler index", function() {
+			var wiki = makeWiki([
+				{title: "Data", type: "application/x-tiddler-dictionary", text: "one: 1\ntwo: 2"}
+			]);
+			var w = render("<$edit-text tiddler=\"Data\" index=\"one\"/>",wiki);
+			w.widget.saveChanges("uno");
+			expect(wiki.extractTiddlerDataItem("Data","one")).toBe("uno");
+			// Other index entries preserved
+			expect(wiki.extractTiddlerDataItem("Data","two")).toBe("2");
+		});
+
+		// manual: Select the text. Copy / Paste -> modified does not change
+		it("skips the store update when the value is unchanged", function() {
+			var wiki = makeWiki([{title: "T", text: "same"}]);
+			var before = wiki.getTiddler("T").fields.modified;
+			var w = render("<$edit-text tiddler=\"T\"/>",wiki);
+			w.widget.saveChanges("same");
+			expect(wiki.getTiddler("T").fields.modified).toBe(before);
+		});
+	});
+
+	// ---------------------------------------------------------------
+	// Refresh behaviour
+	// ---------------------------------------------------------------
+
+	describe("refresh behaviour", function() {
+
+		// manual: render <$edit-text tiddler="T"/>, in New Tiddler and New Tiddler 1
+		// The textarea you are NOT focused on
+		// should live-update to reflect the new text field.
+		it("propagates an external change of the edited tiddler through engine.setText", function() {
+			var wiki = makeWiki([{title: "T", text: "first"}]);
+			var w = render("<$edit-text tiddler=\"T\"/>",wiki);
+			expect(editorValue(w.widget)).toBe("first");
+			var setTextSpy = spyOnSetText(w.widget);
+			wiki.addTiddler({title: "T", text: "second"});
+			refresh(w.root,w.wrapper,["T"]);
+			expect(setTextSpy).toHaveBeenCalled();
+			expect(setTextSpy.calls.mostRecent().args[0]).toBe("second");
+		});
+
+		// manual:
+		// 1. Create tiddlers T (text "initial") and Trigger (text "x").
+		// 2. Render <$edit-text tiddler="T" refreshTitle="Trigger"/>.
+		// 3. Click into the textarea (it now has focus) and type " typed".
+		// 4. Open F12, in console:
+		//      $tw.wiki.addTiddler({title:"T",text:"external"})
+		//    Focus stays on textarea. Store changes, but setText skips
+		//    the DOM write because the node is focused — DOM diverges
+		//    from store (textarea still shows "initial typed").
+		// 5. In console:
+		//      $tw.wiki.addTiddler({title:"Trigger",text:"bump"})
+		//    Textarea should VISIBLY flip to "external" while still
+		//    focused. updateDomNodeText has no focus check.
+		// Without refreshTitle, step 5 does nothing — DOM stays diverged.
+		it("refreshTitle triggers updateDomNodeText even when a different tiddler changes", function() {
+			var wiki = makeWiki([
+				{title: "T", text: "first"},
+				{title: "Trigger", text: "x"}
+			]);
+			var w = render("<$edit-text tiddler=\"T\" refreshTitle=\"Trigger\"/>",wiki);
+			// refreshTitle goes through engine.updateDomNodeText, not setText
+			var updateSpy = jasmine.createSpy("updateDomNodeText");
+			w.widget.engine.updateDomNodeText = updateSpy;
+			wiki.addTiddler({title: "T", text: "updated"});
+			refresh(w.root,w.wrapper,["Trigger"]);
+			expect(updateSpy).toHaveBeenCalledWith("updated");
+		});
+
+		// manual: render <$edit-text tiddler="T" class={{ClassSrc}}/> and
+		// change ClassSrc's text. Inspect the textarea element in devtools
+		// — the class attribute should flip to the new value. This covers
+		// a full re-render (refreshSelf), not just an in-place text update.
+		it("changes to attributes that require a full rerender trigger refreshSelf", function() {
+			// When an attribute like `class` changes via a transcluded variable,
+			// the widget should rerender itself. We simulate that by wrapping the
+			// edit-text inside a transclusion where the class is indirect.
+			var wiki = makeWiki([
+				{title: "T", text: "body"},
+				{title: "ClassSrc", text: "first-class"}
+			]);
+			var w = render(
+				"<$edit-text tiddler=\"T\" class={{ClassSrc}}/>",
+				wiki
+			);
+			expect(w.widget.engine.domNode.className).toBe("first-class");
+			wiki.addTiddler({title: "ClassSrc", text: "second-class"});
+			refresh(w.root,w.wrapper,["ClassSrc"]);
+			// Re-locate the widget because a full refresh creates a new instance
+			var fresh = findEditTextWidget(w.root);
+			expect(fresh.engine.domNode.className).toBe("second-class");
+		});
+	});
+});

package/editions/test/tiddlers/tests/test-edit-widgets/test-edit-text-widget.js

@@ -0,0 +1,198 @@
+/*\
+title: test-edit-text-widget.js
+type: application/javascript
+tags: [[$:/tags/test-spec]]
+
+Covers the `rows` / `autoHeight` / `minHeight` interaction in the
+edit-text widget. Regression guard for issue #9451 / PR #9454 follow-up
+fix (rows=1 autoHeight=yes must still grow).
+
+Assertions target the routing inside SimpleEngine.fixHeight (which
+branch runs, called with which minHeight) — pixel measurement needs a
+real browser.
+
+\*/
+
+"use strict";
+
+describe("Edit-text widget", function() {
+
+	// Shared helpers live in $:/tests/test-edit-widgets/helpers. See that
+	// file for what each helper prepares and where it is used across the suite.
+	var helpers = require("$:/tests/test-edit-widgets/helpers");
+
+	// Local wrapper: every test in THIS file seeds an empty "TestTiddler"
+	// as its default binding target, so we inject that by default.
+	function makeWiki(extraTiddlers) {
+		return helpers.makeWiki(extraTiddlers,{seedTestTiddler: true});
+	}
+
+	// Local alias — `renderEditText` reads more naturally than
+	// `helpers.renderFromAttrs` for the routing tests.
+	function renderEditText(attrs,wiki,tiddlerTitle) {
+		return helpers.renderFromAttrs(attrs,wiki,tiddlerTitle);
+	}
+
+	// ---------------------------------------------------------------
+	// Attribute parsing
+	// ---------------------------------------------------------------
+
+	describe("attribute parsing", function() {
+
+		// manual: on a bare <$edit-text tiddler="T"/>, open devtools and
+		// inspect the widget instance — the element should be a textarea,
+		// there should be no rows attribute, and auto-height should be on.
+		// Manual Preview: Also use the widget-tree
+		it("defaults: tag=textarea, autoHeight=yes, no rows, minHeight=100px", function() {
+			var et = renderEditText({});
+			expect(et.editTag).toBe("textarea");
+			expect(et.editAutoHeight).toBe(true);
+			expect(et.editRows).toBeUndefined();
+			expect(et.editMinHeight).toBe("100px");
+		});
+
+		// manual: render <$edit-text tiddler="T" rows=5 autoHeight="no" minHeight="1em"/>
+		// — the widget's internal state should reflect all three explicit
+		// values, overriding the defaults verified in the previous test.
+		// Manual Preview: Also use the widget-tree
+		it("explicit attributes override defaults (rows, autoHeight, minHeight)", function() {
+			var et = renderEditText({rows: "5", autoHeight: "no", minHeight: "1em"});
+			expect(et.editRows).toBe("5");
+			expect(et.editAutoHeight).toBe(false);
+			expect(et.editMinHeight).toBe("1em");
+		});
+
+		// manual: render <$edit-text tiddler="T" field="caption" tag="textarea"/>
+		// — the element should be a multi-line textarea even though the
+		// field is not `text`.
+		it("tag=textarea override applies to non-text fields", function() {
+			var et = renderEditText({field: "caption", tag: "textarea"});
+			expect(et.editTag).toBe("textarea");
+		});
+
+		// manual: set $:/config/TextEditor/EditorHeight/Mode = "fixed"
+		// (via control panel → settings → editor toolbar, or edit the
+		// tiddler directly). <$edit-text tiddler="T"/> should now behave
+		// as fixed-height (scrollbar on overflow) by default.
+		it("$:/config/TextEditor/EditorHeight/Mode=fixed flips default autoHeight to false", function() {
+			var wiki = makeWiki([
+				{title: "$:/config/TextEditor/EditorHeight/Mode", text: "fixed"}
+			]);
+			var et = renderEditText({},wiki);
+			expect(et.editAutoHeight).toBe(false);
+		});
+
+		// manual: with the same Mode=fixed config as above, an explicit
+		// <$edit-text tiddler="T" autoHeight="yes"/> should still auto-grow
+		// — the per-widget attribute wins over the global config.
+		it("explicit autoHeight=yes overrides Mode=fixed config", function() {
+			var wiki = makeWiki([
+				{title: "$:/config/TextEditor/EditorHeight/Mode", text: "fixed"}
+			]);
+			var et = renderEditText({autoHeight: "yes"},wiki);
+			expect(et.editAutoHeight).toBe(true);
+		});
+	});
+
+	// ---------------------------------------------------------------
+	// DOM node construction (SimpleEngine)
+	// ---------------------------------------------------------------
+
+	describe("DOM node construction (non-toolbar SimpleEngine)", function() {
+
+		// manual: render <$edit-text tiddler="T" rows=1/> and inspect the
+		// element — it should carry rows="1". Proves SimpleEngine copies
+		// widget.editRows onto the DOM element.
+		it("sets the rows attribute on the DOM node when rows is specified", function() {
+			var et = renderEditText({rows: "1"});
+			expect(et.engine.domNode.getAttribute("rows")).toBe("1");
+		});
+	});
+
+	// ---------------------------------------------------------------
+	// fixHeight routing — the core of the fix
+	// ---------------------------------------------------------------
+
+	describe("fixHeight routing", function() {
+
+		var originalResize, resizeSpy;
+
+		beforeEach(function() {
+			originalResize = $tw.utils.resizeTextAreaToFit;
+			resizeSpy = jasmine.createSpy("resizeTextAreaToFit").and.returnValue(0);
+			$tw.utils.resizeTextAreaToFit = resizeSpy;
+		});
+
+		afterEach(function() {
+			$tw.utils.resizeTextAreaToFit = originalResize;
+		});
+
+		// Make the SimpleEngine.fixHeight think we are in a real DOM so it
+		// actually reaches the $tw.utils.resizeTextAreaToFit call. Without
+		// this the engine short-circuits because fakedom nodes carry
+		// isTiddlyWikiFakeDom === true.
+		function callFixHeight(et) {
+			et.engine.domNode.isTiddlyWikiFakeDom = false;
+			et.engine.fixHeight();
+		}
+
+		// manual: render <$edit-text tiddler="T" rows=1 autoHeight=yes minHeight=1em/>
+		// (the TiddlyTools idiom). In 5.4.0 pre-fix, the textarea stayed
+		// a single row forever; after the fix, it starts at 1 row and
+		// grows as you type newlines. This covers BRANCH A (autoHeight=yes)
+		// of SimpleEngine.fixHeight: resize is called with minHeight even
+		// when rows is set. Strict superset of the no-rows baseline.
+		it("rows=1 autoHeight=yes minHeight=1em still calls resize (regression test for the PR #9454 follow-up fix)", function() {
+			var et = renderEditText({rows: "1", autoHeight: "yes", minHeight: "1em"});
+			callFixHeight(et);
+			expect(resizeSpy).toHaveBeenCalled();
+			expect(resizeSpy.calls.mostRecent().args[1]).toBe("1em");
+		});
+
+		// manual: render <$edit-text tiddler="T" rows=5 autoHeight=no/> —
+		// the textarea must stay locked at exactly 5 rows tall, even if
+		// you paste in 50 lines (vertical scrollbar appears inside).
+		it("rows=5 autoHeight=no does NOT call resize and does NOT apply the fixed-height fallback", function() {
+			var et = renderEditText({rows: "5", autoHeight: "no"});
+			callFixHeight(et);
+			expect(resizeSpy).not.toHaveBeenCalled();
+			// rows attribute governs height — CSS height must remain unset
+			expect(et.engine.domNode.style.height).toBe("");
+		});
+
+		// manual: set $:/config/TextEditor/EditorHeight/Height = "250px",
+		// then render <$edit-text tiddler="T" autoHeight="no"/> — the
+		// textarea should be exactly 250px tall regardless of content.
+		it("autoHeight=no with no rows applies the fixed-height fallback from config", function() {
+			var wiki = makeWiki([
+				{title: "$:/config/TextEditor/EditorHeight/Height", text: "250px"}
+			]);
+			var et = renderEditText({autoHeight: "no"},wiki);
+			callFixHeight(et);
+			expect(resizeSpy).not.toHaveBeenCalled();
+			expect(et.engine.domNode.style.height).toBe("250px");
+		});
+
+		// manual: set $:/config/TextEditor/EditorHeight/Height = "5px",
+		// render <$edit-text tiddler="T" autoHeight="no"/> — the textarea
+		// should be 20px tall (clamped), not a sliver, so it stays usable.
+		it("autoHeight=no fallback height is clamped to at least 20px", function() {
+			var wiki = makeWiki([
+				{title: "$:/config/TextEditor/EditorHeight/Height", text: "5px"}
+			]);
+			var et = renderEditText({autoHeight: "no"},wiki);
+			callFixHeight(et);
+			expect(et.engine.domNode.style.height).toBe("20px");
+		});
+
+		// manual: render <$edit-text tiddler="T" field="caption" autoHeight="no"/>
+		// — the element is a single-line <input> and the CSS height should
+		// remain unset (no height fallback applies to inputs).
+		it("tag=input: neither resize nor fixed-height fallback runs", function() {
+			var et = renderEditText({field: "caption", autoHeight: "no"});
+			callFixHeight(et);
+			expect(resizeSpy).not.toHaveBeenCalled();
+			expect(et.engine.domNode.style.height).toBe("");
+		});
+	});
+});

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

@@ -18,4 +18,15 @@ describe("fakedom tests", function() {
 		expect($tw.fakeDocument.createTextNode("text").nodeType).toBe(3);
 		expect($tw.fakeDocument.createTextNode("text").TEXT_NODE).toBe(3);
 	});
+
+	// Real CSSStyleDeclaration returns undefined for Symbol property keys.
+	// Without a guard, the TW_Style Proxy throws on Symbol access. This bites
+	// in practice when Jasmine pretty-prints fakedom elements on failure.
+	// See related TODO in test-select-widget.js
+	it("returns undefined for Symbol property access on element.style", function() {
+		var el = $tw.fakeDocument.createElement("div");
+		expect(function() { return el.style[Symbol.toPrimitive]; }).not.toThrow();
+		expect(el.style[Symbol.toPrimitive]).toBeUndefined();
+		expect(function() { el.style[Symbol.iterator] = "x"; }).not.toThrow();
+	});
 });