termrender 0.6.0__tar.gz → 0.6.1__tar.gz

{termrender-0.6.0 → termrender-0.6.1}/CHANGELOG.md

@@ -1,6 +1,23 @@
 # CHANGELOG
 
 
+## v0.6.1 (2026-04-08)
+
+### Bug Fixes
+
+- **borders**: Grow render_box to fit overflowing content and titles
+  ([`dc108c8`](https://github.com/CaptainCrouton89/termrender/commit/dc108c8242763828245569f719abce64b26ddf5b))
+
+mermaid-ascii's --maxWidth is non-strict, so a child mermaid block can return lines wider than the
+  panel's allocated content area. Previously the side walls floated outward to accommodate the
+  content while the top/bottom borders stayed at the requested width, leaving corner glyphs one
+  column inside the side walls and producing a visibly jagged box.
+
+render_box now measures the widest content line (and the title) and grows its effective width up
+  front so all four borders land at the same column. Trade-off: the box may overflow its parent
+  allocation, but the box itself is internally consistent.
+
+
 ## v0.6.0 (2026-04-07)
 
 ### Features

{termrender-0.6.0 → termrender-0.6.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: termrender
-Version: 0.6.0
+Version: 0.6.1
 Summary: Rich terminal rendering of directive-flavored markdown
 Project-URL: Homepage, https://github.com/CaptainCrouton89/termrender
 Project-URL: Repository, https://github.com/CaptainCrouton89/termrender

{termrender-0.6.0 → termrender-0.6.1}/src/termrender/renderers/borders.py

@@ -30,6 +30,25 @@ def render_box(
     dash_v = visual_len("─")
     corner_v = visual_len("┌")  # same as ┐, └, ┘
 
+    # Grow the box if any content line (or the title) won't fit at the
+    # requested width. mermaid-ascii's --maxWidth is non-strict, so a child
+    # mermaid block can return lines wider than its allocated content area.
+    # Truncating would corrupt the diagram; growing keeps the box's top,
+    # bottom, and side borders aligned at the same column even if it
+    # overflows the parent's allocation.
+    content_max = visual_len("")
+    for cl in content_lines:
+        cl_w = visual_len(cl)
+        if cl_w > content_max:
+            content_max = cl_w
+    required_for_content = content_max + 2 + 2 * border_v  # pads + walls
+    required_for_title = 0
+    if title:
+        title_part_w = dash_v + 2 + visual_len(title)  # "─ TITLE "
+        # Reserve at least one trailing dash so the corner has chrome.
+        required_for_title = title_part_w + dash_v + 2 * border_v
+    width = max(width, required_for_content, required_for_title)
+
     # inner_w = space between the two vertical borders
     inner_w = width - 2 * border_v
     # content_w = space for actual content (inner minus 1-space padding each side)

{termrender-0.6.0 → termrender-0.6.1}/tests/test_column_alignment.py

@@ -81,6 +81,30 @@ c/
 ::::
 """
 
+# A panel nested inside :::col whose content (a wide mermaid diagram) exceeds
+# the column allocation. The inner panel's side walls and corner glyphs must
+# stay aligned even when content forces the panel to grow past its allotment.
+NESTED_PANEL_OVERFLOW_INPUT = """\
+::::::panel{title="Outer" color="cyan"}
+:::::columns
+::::col{width="58%"}
+:::panel{title="Request Flow" color="blue"}
+```mermaid
+graph TD
+    A[Edge gateway<br/>accepts request] --> B{Token valid?}
+    B -->|yes| C[Route via LB<br/>to backend pool]
+    B -->|no| D[Reject 401,<br/>write audit log]
+    C --> E[Service responds,<br/>metrics emitted]
+```
+:::
+::::
+::::col{width="42%"}
+right
+::::
+:::::
+::::::
+"""
+
 
 class TestColumnAlignment(unittest.TestCase):
 
@@ -132,6 +156,58 @@ class TestColumnAlignment(unittest.TestCase):
                 f"Line {i} has visual width {w}, expected 40: {line!r}",
             )
 
+    def test_nested_panel_corners_align_with_side_walls(self):
+        # When a panel inside a column receives content wider than the column
+        # allocation, both the side walls AND the top/bottom border glyphs
+        # must extend to the same width. Otherwise the corner glyphs (┐ ┘)
+        # land one column inside the side walls (│), producing a jagged box.
+        from termrender.style import _char_width
+
+        output = render(NESTED_PANEL_OVERFLOW_INPUT, width=80, color=False)
+        lines = output.split("\n")
+        if lines and lines[-1] == "":
+            lines = lines[:-1]
+
+        def visual_positions(line, glyphs):
+            pos = 0
+            found = []
+            for ch in line:
+                if ch == "\033":
+                    continue
+                if ch in glyphs:
+                    found.append(pos)
+                pos += _char_width(ch)
+            return found
+
+        # The outer panel's left wall is always at pos 0 and the right wall
+        # at the rightmost glyph. The inner panel's right border is the
+        # next-most-right border glyph in any row that contains both the
+        # outer panel's walls and inner-panel content. Across all such rows
+        # the inner panel's right border position must be constant.
+        inner_right_positions = []
+        for line in lines:
+            glyphs = sorted(set(visual_positions(line, "┌┐└┘│")))
+            # Skip rows that don't span the inner panel (e.g. outer-only).
+            if len(glyphs) < 3:
+                continue
+            outer_right = glyphs[-1]
+            # Inner panel's right border is whichever glyph sits just inside
+            # the outer right wall — i.e. the next-rightmost.
+            inner_right = glyphs[-2]
+            # Ignore the inner panel's LEFT wall (which on bare side-wall
+            # rows might appear as glyphs[1]) — we only care about the
+            # right-side glyph adjacent to the outer right wall.
+            if inner_right == glyphs[0]:
+                continue
+            inner_right_positions.append(inner_right)
+
+        unique = set(inner_right_positions)
+        self.assertEqual(
+            len(unique),
+            1,
+            f"Inner panel right border drifts across rows: {sorted(unique)}",
+        )
+
 
 if __name__ == "__main__":
     unittest.main()