Make TextBlock shrink in layout

Author: xoofx

site/docs/controls/textblock.md

@@ -36,6 +36,9 @@ new TextBlock("This is a long single line that will be trimmed.")
     .Trimming(TextTrimming.EndEllipsis);
 ```
 
+When `Wrap` is `false`, `TextBlock` can shrink horizontally during layout, so it works well in patterns such as
+`Grid(Star + Auto)` where trailing actions should remain visible while the text trims.
+
 ## Alignment
 
 `TextAlignment` controls how the text is aligned inside the available width:

site/docs/specs/controls/textblock.md

@@ -66,7 +66,7 @@ There are no events and no input handling.
 
 ### Measurement model
 
-`TextBlock` measures to a fixed size based on:
+`TextBlock` measures based on:
 - the text's cell width (not string length)
 - the wrap flag and available width
 - the available height (clamped)
@@ -76,8 +76,14 @@ Let:
 - `naturalWidth = TerminalTextUtility.GetWidth(text)`
 - `width = min(constraints.MaxWidth, naturalWidth)`
 
-When `Wrap` is false or `width == 0`:
-- desired size is `(width, 1)` (height is clamped to 1)
+When `Wrap` is false:
+- `Natural.Width` is the full text width
+- `Min.Width` is `1` for non-empty text (`0` for empty text), so single-line text can shrink during layout
+- `Max.Width` is the full text width
+- `FlexShrinkX = 1` when the text is wider than its minimum
+
+When `Wrap` is true and `width == 0`:
+- desired size is `(0, 1)` (height is clamped to 1)
 
 When `Wrap` is true:
 - height is computed as the number of wrapped lines for the given width (at least 1)
@@ -86,6 +92,8 @@ When `Wrap` is true:
 Notes:
 - The measured width does not attempt to "stretch to fill" when there is more horizontal space than the text requires.
   Stretching is handled by layout via `HorizontalAlignment = Align.Stretch` if desired.
+- This horizontal shrink budget is what allows layouts such as `Grid(Star + Auto)` to keep trailing controls visible
+  while the text trims in the remaining width.
 
 ### Rendering model
 

src/XenoAtom.Terminal.UI.Tests/GridLayoutTests.cs

@@ -114,6 +114,32 @@ public void Auto_Column_Shrinks_To_Preserve_Star_MinWidth()
         Assert.AreEqual(new Rectangle(7, 0, 3, 1), star.Bounds);
     }
 
+    [TestMethod]
+    public void Star_Text_Column_Shrinks_Before_Auto_Button_Column()
+    {
+        var grid = new Grid();
+        grid.ColumnDefinitions.AddRange(
+            new ColumnDefinition { Width = GridLength.Star(1) },
+            new ColumnDefinition { Width = GridLength.Auto });
+        grid.RowDefinitions.Add(new RowDefinition { Height = GridLength.Auto });
+
+        var text = new TextBlock("HelloWorld")
+        {
+            Wrap = false,
+            Trimming = TextTrimming.EndEllipsis,
+        };
+        var button = new Button("X");
+
+        grid.Cell(text, 0, 0);
+        grid.Cell(button, 0, 1);
+
+        grid.Measure(new Size(8, 1));
+        grid.Arrange(new Rectangle(0, 0, 8, 1));
+
+        Assert.AreEqual(3, text.Bounds.Width);
+        Assert.AreEqual(new Rectangle(3, 0, 5, 1), button.Bounds);
+    }
+
     private sealed class FillVisual : Visual
     {
         private readonly Size _desired;

src/XenoAtom.Terminal.UI.Tests/TextBlockRenderingTests.cs

@@ -14,6 +14,23 @@ namespace XenoAtom.Terminal.UI.Tests;
 [TestClass]
 public sealed class TextBlockRenderingTests
 {
+    [TestMethod]
+    public void TextBlock_SingleLine_Reports_Horizontal_Shrink_Budget()
+    {
+        var tb = new TextBlock("HelloWorld")
+        {
+            Wrap = false,
+            Trimming = TextTrimming.EndEllipsis,
+        };
+
+        tb.Measure(LayoutConstraints.Unbounded);
+
+        Assert.AreEqual(1, tb.MeasureHints.Min.Width);
+        Assert.AreEqual(10, tb.MeasureHints.Natural.Width);
+        Assert.AreEqual(10, tb.MeasureHints.Max.Width);
+        Assert.AreEqual(1, tb.MeasureHints.FlexShrinkX);
+    }
+
     [TestMethod]
     public void TextBlock_EndEllipsis_Trims_To_Width()
     {

src/XenoAtom.Terminal.UI/Controls/TextBlock.cs

@@ -121,10 +121,24 @@ protected override SizeHints MeasureCore(in LayoutConstraints constraints)
         var text = Text ?? string.Empty;
         var naturalWidth = TerminalTextUtility.GetWidth(text.AsSpan());
         var width = Math.Max(0, Math.Min(availableSize.Width, naturalWidth));
+        var lineHeight = Math.Min(Math.Max(0, availableSize.Height), 1);
 
-        if (!Wrap || width == 0)
+        if (!Wrap)
         {
-            return SizeHints.Fixed(new Size(width, Math.Min(Math.Max(0, availableSize.Height), 1)));
+            var minWidth = naturalWidth > 0 ? 1 : 0;
+            return SizeHints.Flex(
+                new Size(minWidth, lineHeight),
+                new Size(naturalWidth, lineHeight),
+                new Size(naturalWidth, lineHeight),
+                growX: 0,
+                growY: 0,
+                shrinkX: naturalWidth > minWidth ? 1 : 0,
+                shrinkY: 0);
+        }
+
+        if (width == 0)
+        {
+            return SizeHints.Fixed(new Size(width, lineHeight));
         }
 
         var height = CountWrappedLines(text.AsSpan(), Math.Max(1, width));