ratatui_ruby 0.6.0 → 0.7.1

data/lib/ratatui_ruby/layout/rect.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+# SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+# SPDX-License-Identifier: AGPL-3.0-or-later
+
+module RatatuiRuby
+  module Layout
+    # Defines a rectangular area in the terminal grid.
+    #
+    # Geometry management involves passing groups of four integers (`x, y, width, height`) repeatedly.
+    # This is verbose and prone to parameter mismatch errors.
+    #
+    # This class encapsulates the geometry. It provides a standard primitive for passing area definitions
+    # between layout engines and rendering functions.
+    #
+    # Use it when manual positioning is required or when querying layout results.
+    #
+    # === Examples
+    #
+    #   area = Layout::Rect.new(x: 0, y: 0, width: 80, height: 24)
+    #   puts area.width # => 80
+    class Rect < Data.define(:x, :y, :width, :height)
+      ##
+      # :attr_reader: x
+      # X coordinate (column) of the top-left corner (Integer, coerced via +to_int+ or +to_i+).
+
+      ##
+      # :attr_reader: y
+      # Y coordinate (row) of the top-left corner (Integer, coerced via +to_int+ or +to_i+).
+
+      ##
+      # :attr_reader: width
+      # Width in characters (Integer, coerced via +to_int+ or +to_i+).
+
+      ##
+      # :attr_reader: height
+      # Height in characters (Integer, coerced via +to_int+ or +to_i+).
+
+      # Creates a new Rect.
+      #
+      # All parameters accept any object responding to +to_int+ or +to_i+ (duck-typed).
+      #
+      # [x] Column index (Numeric).
+      # [y] Row index (Numeric).
+      # [width] Width in columns (Numeric).
+      # [height] Height in rows (Numeric).
+      def initialize(x: 0, y: 0, width: 0, height: 0)
+        super(
+          x: Integer(x),
+          y: Integer(y),
+          width: Integer(width),
+          height: Integer(height)
+        )
+      end
+
+      # Tests whether a point is inside this rectangle.
+      #
+      # Essential for hit testing mouse clicks against layout regions.
+      #
+      #   area = Layout::Rect.new(x: 10, y: 5, width: 20, height: 10)
+      #   area.contains?(15, 8) # => true
+      #   area.contains?(5, 8)  # => false
+      #
+      # [px]
+      #   X coordinate to test (column).
+      # [py]
+      #   Y coordinate to test (row).
+      #
+      # Returns true if the point (px, py) is within the rectangle bounds.
+      def contains?(px, py)
+        px >= x && px < x + width && py >= y && py < y + height
+      end
+
+      # Tests whether this rectangle overlaps with another.
+      #
+      # Essential for determining if a widget is visible within a viewport or clipping area.
+      #
+      #   viewport = Layout::Rect.new(x: 0, y: 0, width: 80, height: 24)
+      #   widget = Layout::Rect.new(x: 70, y: 20, width: 20, height: 10)
+      #   viewport.intersects?(widget) # => true (partial overlap)
+      #
+      # [other]
+      #   Another Rect to test against.
+      #
+      # Returns true if the rectangles overlap.
+      def intersects?(other)
+        x < other.x + other.width &&
+          x + width > other.x &&
+          y < other.y + other.height &&
+          y + height > other.y
+      end
+
+      # Returns the overlapping area between this rectangle and another.
+      #
+      # Essential for calculating visible portions of widgets inside scroll views.
+      #
+      #   viewport = Layout::Rect.new(x: 0, y: 0, width: 80, height: 24)
+      #   widget = Layout::Rect.new(x: 70, y: 20, width: 20, height: 10)
+      #   visible = viewport.intersection(widget)
+      #   # => Rect(x: 70, y: 20, width: 10, height: 4)
+      #
+      # [other]
+      #   Another Rect to intersect with.
+      #
+      # Returns a new Rect representing the intersection, or +nil+ if no overlap.
+      def intersection(other)
+        return nil unless intersects?(other)
+
+        new_x = [x, other.x].max
+        new_y = [y, other.y].max
+        new_right = [x + width, other.x + other.width].min
+        new_bottom = [y + height, other.y + other.height].min
+
+        Rect.new(x: new_x, y: new_y, width: new_right - new_x, height: new_bottom - new_y)
+      end
+    end
+  end
+end

data/lib/ratatui_ruby/layout.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+# SPDX-License-Identifier: AGPL-3.0-or-later
+
+module RatatuiRuby
+  # Layout primitives for geometry and space distribution.
+  #
+  # This module mirrors +ratatui::layout+ and contains:
+  # - {Rect} — Rectangle geometry
+  # - {Constraint} — Sizing rules
+  # - {Layout} — Space distribution
+  module Layout
+  end
+end
+
+require_relative "layout/rect"
+require_relative "layout/constraint"
+require_relative "layout/layout"

data/lib/ratatui_ruby/list_state.rb

@@ -18,7 +18,7 @@ module RatatuiRuby
   # == Thread/Ractor Safety
   #
   # ListState is *not* Ractor-shareable. It contains mutable internal state.
-  # Store it in instance variables, not in immutable TEA Models.
+  # Store it in instance variables, not in immutable Models.
   #
   # == Example
   #
@@ -26,7 +26,7 @@ module RatatuiRuby
   #   @list_state.select(2) # Select third item
   #
   #   RatatuiRuby.draw do |frame|
-  #     list = RatatuiRuby::List.new(items: ["A", "B", "C", "D", "E"])
+  #     list = RatatuiRuby::Widgets::List.new(items: ["A", "B", "C", "D", "E"])
   #     frame.render_stateful_widget(list, frame.area, @list_state)
   #   end
   #

data/lib/ratatui_ruby/schema/layout.rb

@@ -32,7 +32,7 @@ module RatatuiRuby
     # :attr_reader: constraints
     # Array of rules defining section sizes.
     #
-    # See RatatuiRuby::Constraint.
+    # See RatatuiRuby::Layout::Constraint.
 
     ##
     # :attr_reader: children

data/lib/ratatui_ruby/schema/row.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+# SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+# SPDX-License-Identifier: AGPL-3.0-or-later
+
+module RatatuiRuby
+  # A styled table row combining cells with optional row-level styling.
+  #
+  # By default, Table rows are arrays of cell content. For more control over styling
+  # individual rows, wrap the cells in a Row object to apply row-level style.
+  #
+  # The cells can be Strings, Text::Spans, Text::Lines, Paragraphs, or Cells.
+  # The style applies to the entire row background.
+  #
+  # === Examples
+  #
+  #   # Row with red background
+  #   Row.new(cells: ["Error", "Something went wrong"], style: Style.new(bg: :red))
+  #
+  #   # Row with styled cells and custom height
+  #   Row.new(
+  #     cells: [
+  #       Text::Span.new(content: "Status", style: Style.new(modifiers: [:bold])),
+  #       Text::Span.new(content: "OK", style: Style.new(fg: :green))
+  #     ],
+  #     height: 2
+  #   )
+  class Row < Data.define(:cells, :style, :height, :top_margin, :bottom_margin)
+    ##
+    # :attr_reader: cells
+    # The cells to display (Array of Strings, Text::Spans, Text::Lines, Paragraphs, or Cells).
+
+    ##
+    # :attr_reader: style
+    # The style to apply to the row (optional Style).
+
+    ##
+    # :attr_reader: height
+    # Fixed row height in lines (optional Integer).
+
+    ##
+    # :attr_reader: top_margin
+    # Margin above the row in lines (optional Integer).
+
+    ##
+    # :attr_reader: bottom_margin
+    # Margin below the row in lines (optional Integer).
+
+    # Creates a new Row.
+    #
+    # [cells] Array of Strings, Text::Spans, Text::Lines, Paragraphs, or Cells.
+    # [style] Style object (optional).
+    # [height] Integer for fixed height (optional).
+    # [top_margin] Integer for top margin (optional).
+    # [bottom_margin] Integer for bottom margin (optional).
+    def initialize(cells:, style: nil, height: nil, top_margin: nil, bottom_margin: nil)
+      super(
+        cells:,
+        style:,
+        height: height.nil? ? nil : Integer(height),
+        top_margin: top_margin.nil? ? nil : Integer(top_margin),
+        bottom_margin: bottom_margin.nil? ? nil : Integer(bottom_margin)
+      )
+    end
+  end
+end

data/lib/ratatui_ruby/schema/table.rb

@@ -20,21 +20,21 @@ module RatatuiRuby
   # Run the interactive demo from the terminal:
   #
   #   ruby examples/widget_table_flex/app.rb
-  class Table < Data.define(:header, :rows, :widths, :highlight_style, :highlight_symbol, :highlight_spacing, :column_highlight_style, :cell_highlight_style, :selected_row, :selected_column, :offset, :block, :footer, :flex, :style, :column_spacing)
+  class Table < Data.define(:header, :rows, :widths, :row_highlight_style, :highlight_symbol, :highlight_spacing, :column_highlight_style, :cell_highlight_style, :selected_row, :selected_column, :offset, :block, :footer, :flex, :style, :column_spacing)
     ##
     # :attr_reader: header
-    # Header row content (Array of Strings).
+    # Header row content (Array of Strings, Text::Spans, Text::Lines, or Paragraphs).
 
     ##
     # :attr_reader: rows
-    # Data rows (Array of Arrays of Strings).
+    # Data rows (Array of Arrays). Each cell can be String, Text::Span, Text::Line, Paragraph, or Cell.
 
     ##
     # :attr_reader: widths
     # Column width constraints (Array of Constraint).
 
     ##
-    # :attr_reader: highlight_style
+    # :attr_reader: row_highlight_style
     # Style for the selected row.
 
     ##
@@ -83,7 +83,7 @@ module RatatuiRuby
 
     ##
     # :attr_reader: footer
-    # Footer row content (Array of Strings).
+    # Footer row content (Array of Strings, Text::Spans, Text::Lines, or Paragraphs).
 
     ##
     # :attr_reader: flex
@@ -99,10 +99,10 @@ module RatatuiRuby
 
     # Creates a new Table.
     #
-    # [header] Array of strings/paragraphs.
-    # [rows] 2D Array of strings/paragraphs.
+    # [header] Array of strings, Text::Spans, Text::Lines, or paragraphs.
+    # [rows] 2D Array where each cell is String, Text::Span, Text::Line, Paragraph, or Cell.
     # [widths] Array of Constraints.
-    # [highlight_style] Style object.
+    # [row_highlight_style] Style object.
     # [highlight_symbol] String.
     # [highlight_spacing] Symbol (optional, default: <tt>:when_selected</tt>).
     # [column_highlight_style] Style object.
@@ -115,12 +115,12 @@ module RatatuiRuby
     # [flex] Symbol (optional, default: <tt>:legacy</tt>).
     # [style] Style object or Hash (optional).
     # [column_spacing] Integer (optional, default: 1).
-    def initialize(header: nil, rows: [], widths: [], highlight_style: nil, highlight_symbol: "> ", highlight_spacing: :when_selected, column_highlight_style: nil, cell_highlight_style: nil, selected_row: nil, selected_column: nil, offset: nil, block: nil, footer: nil, flex: :legacy, style: nil, column_spacing: 1)
+    def initialize(header: nil, rows: [], widths: [], row_highlight_style: nil, highlight_symbol: "> ", highlight_spacing: :when_selected, column_highlight_style: nil, cell_highlight_style: nil, selected_row: nil, selected_column: nil, offset: nil, block: nil, footer: nil, flex: :legacy, style: nil, column_spacing: 1)
       super(
         header:,
         rows:,
         widths:,
-        highlight_style:,
+        row_highlight_style:,
         highlight_symbol:,
         highlight_spacing:,
         column_highlight_style:,

data/lib/ratatui_ruby/schema/text.rb

@@ -94,7 +94,7 @@ module RatatuiRuby
     #       Text::Span.styled("kerrick", Style.new(fg: :blue))
     #     ]
     #   )
-    class Line < Data.define(:spans, :alignment)
+    class Line < Data.define(:spans, :alignment, :style)
       ##
       # :attr_reader: spans
       # Array of Span objects.
@@ -105,11 +105,18 @@ module RatatuiRuby
       #
       # <tt>:left</tt>, <tt>:center</tt>, or <tt>:right</tt>.
 
+      ##
+      # :attr_reader: style
+      # Line-level style applied to all spans.
+      #
+      # A Style object that sets colors/modifiers for the entire line.
+
       # Creates a new Line.
       #
       # [spans] Array of Span objects (or Strings).
       # [alignment] Symbol (optional).
-      def initialize(spans: [], alignment: nil)
+      # [style] Style object (optional).
+      def initialize(spans: [], alignment: nil, style: nil)
         super
       end
 
@@ -119,6 +126,24 @@ module RatatuiRuby
       def self.from_string(content, alignment: nil)
         new(spans: [Span.new(content:, style: nil)], alignment:)
       end
+
+      # Calculates the display width of this line in terminal cells.
+      #
+      # Sums the widths of all span contents using the same unicode-aware
+      # algorithm as Text.width. Useful for layout calculations.
+      #
+      # === Examples
+      #
+      #   line = Text::Line.new(spans: [
+      #     Text::Span.new(content: "Hello "),
+      #     Text::Span.new(content: "世界")
+      #   ])
+      #   line.width  # => 10 (6 ASCII + 4 CJK)
+      #
+      # Returns: Integer (number of terminal cells)
+      def width
+        RatatuiRuby::Text.width(spans.map { |s| s.content.to_s }.join)
+      end
     end
 
     ##

data/lib/ratatui_ruby/style/style.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+# SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+# SPDX-License-Identifier: AGPL-3.0-or-later
+
+module RatatuiRuby
+  module Style
+    # Defines colors and text modifiers.
+    #
+    # The terminal is traditionally monochrome, but efficient interfaces use color to convey meaning.
+    # Red for errors. Green for success. Bold for headers.
+    #
+    # This value object encapsulates those choices. It applies foreground and background colors. It adds effects like italics or blinking.
+    #
+    # Use it to theme your application or highlight critical data.
+    #
+    # === Examples
+    #
+    #   # Standard colors
+    #   Style::Style.new(fg: :red, bg: :white, modifiers: [:bold])
+    #
+    #   # Hex colors
+    #   Style::Style.new(fg: "#ff00ff")
+    #
+    # === Supported Colors
+    #
+    # ==== Integer
+    # Represents an indexed color from the Xterm 256-color palette (0-255).
+    # * <tt>0</tt>–<tt>15</tt>: Standard and bright ANSI colors.
+    # * <tt>16</tt>–<tt>231</tt>: {6x6x6 Color Cube}[https://en.wikipedia.org/wiki/ANSI_escape_code#8-bit].
+    # * <tt>232</tt>–<tt>255</tt>: Grayscale ramp.
+    #
+    # ==== Symbol
+    # Represents a named color from the standard ANSI palette. Supported values:
+    # * <tt>:black</tt>, <tt>:red</tt>, <tt>:green</tt>, <tt>:yellow</tt>,
+    #   <tt>:blue</tt>, <tt>:magenta</tt>, <tt>:cyan</tt>, <tt>:gray</tt>
+    # * <tt>:dark_gray</tt>, <tt>:light_red</tt>, <tt>:light_green</tt>,
+    #   <tt>:light_yellow</tt>, <tt>:light_blue</tt>, <tt>:light_magenta</tt>,
+    #   <tt>:light_cyan</tt>, <tt>:white</tt>
+    #
+    # ==== String
+    # Represents a specific RGB color using a Hex code (<tt>"#RRGGBB"</tt>).
+    # Requires a terminal emulator with "True Color" (24-bit color) support.
+    class Style < Data.define(:fg, :bg, :modifiers)
+      ##
+      # :attr_reader: fg
+      # Foreground color.
+      #
+      # Symbol (<tt>:red</tt>), Hex String (<tt>"#ffffff"</tt>), or Integer (0-255).
+
+      ##
+      # :attr_reader: bg
+      # Background color.
+      #
+      # Symbol (<tt>:black</tt>), Hex String (<tt>"#000000"</tt>), or Integer (0-255).
+
+      ##
+      # :attr_reader: modifiers
+      # Text effects.
+      #
+      # Array of symbols: <tt>:bold</tt>, <tt>:dim</tt>, <tt>:italic</tt>, <tt>:underlined</tt>,
+      # <tt>:slow_blink</tt>, <tt>:rapid_blink</tt>, <tt>:reversed</tt>, <tt>:hidden</tt>, <tt>:crossed_out</tt>.
+
+      # Creates a new Style.
+      #
+      # [fg] Color (Symbol/String/Integer).
+      # [bg] Color (Symbol/String/Integer).
+      # [modifiers] Array of Symbols.
+      def initialize(fg: nil, bg: nil, modifiers: [])
+        super
+      end
+
+      # Returns an empty style.
+      #
+      # Use this as a baseline to prevent style inheritance issues or when no styling is required.
+      def self.default
+        new
+      end
+    end
+  end
+end

data/lib/ratatui_ruby/style.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+# SPDX-License-Identifier: AGPL-3.0-or-later
+
+module RatatuiRuby
+  # Styling primitives for colors and text effects.
+  #
+  # This module mirrors +ratatui::style+ and contains:
+  # - {Style} — Colors and modifiers
+  module Style
+  end
+end
+
+require_relative "style/style"

data/lib/ratatui_ruby/table_state.rb

@@ -18,7 +18,7 @@ module RatatuiRuby
   #   @table_state.select_column(0) # Select first column
   #
   #   RatatuiRuby.draw do |frame|
-  #     table = RatatuiRuby::Table.new(rows: [...], widths: [...])
+  #     table = RatatuiRuby::Widgets::Table.new(rows: [...], widths: [...])
   #     frame.render_stateful_widget(table, frame.area, @table_state)
   #   end
   #

data/lib/ratatui_ruby/test_helper/snapshot.rb

@@ -252,6 +252,30 @@ module RatatuiRuby
         end
       end
 
+      ##
+      # Returns the current buffer content as an ANSI-encoded string.
+      #
+      # The rich snapshot assertion captures styled output. Sometimes you need the raw ANSI
+      # string for debugging, custom assertions, or programmatic inspection.
+      #
+      # This method renders the buffer with escape codes for colors and modifiers.
+      # You can `cat` the output to see exactly what the terminal would display.
+      #
+      # === Example
+      #
+      #   with_test_terminal(80, 25) do
+      #     RatatuiRuby.run do |tui|
+      #       tui.draw tui.paragraph(text: "Hello", block: tui.block(title: "Test"))
+      #       break
+      #     end
+      #     ansi_output = render_rich_buffer
+      #     puts ansi_output  # Shows styled output with escape codes
+      #   end
+      #
+      def render_rich_buffer
+        _render_buffer_with_ansi
+      end
+
       private def _render_buffer_with_ansi
         RatatuiRuby.get_buffer_content # Ensure buffer is fresh if needed
 

data/lib/ratatui_ruby/test_helper/style_assertions.rb

@@ -86,7 +86,7 @@ module RatatuiRuby
       #
       # === Examples
       #
-      #   header = RatatuiRuby::Rect.new(x: 0, y: 0, width: 80, height: 1)
+      #   header = RatatuiRuby::Layout::Rect.new(x: 0, y: 0, width: 80, height: 1)
       #   assert_area_style(header, bg: :blue, modifiers: [:bold])
       #
       #   assert_area_style({ x: 0, y: 0, w: 10, h: 1 }, fg: :red)

data/lib/ratatui_ruby/tui/buffer_factories.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+# SPDX-License-Identifier: AGPL-3.0-or-later
+
+module RatatuiRuby
+  class TUI
+    # Buffer inspection factory methods for Session.
+    #
+    # Provides convenient access to Buffer::Cell for testing
+    # and buffer inspection purposes.
+    module BufferFactories
+      # Creates a Buffer::Cell (for testing).
+      # @return [Buffer::Cell]
+      def cell(...)
+        Buffer::Cell.new(...)
+      end
+    end
+  end
+end

data/lib/ratatui_ruby/tui/canvas_factories.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+# SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+# SPDX-License-Identifier: AGPL-3.0-or-later
+
+module RatatuiRuby
+  class TUI
+    # Canvas shape factory methods for Session.
+    #
+    # Provides convenient access to Widgets::Shape::* classes
+    # for creating custom drawings on Canvas widgets.
+    module CanvasFactories
+      # Creates a map shape for Canvas.
+      # @return [Widgets::Shape::Map]
+      def shape_map(...)
+        Widgets::Shape::Map.new(...)
+      end
+
+      # Creates a line shape for Canvas.
+      # @return [Widgets::Shape::Line]
+      def shape_line(...)
+        Widgets::Shape::Line.new(...)
+      end
+
+      # Creates a point (single pixel) shape for Canvas.
+      # @return [Widgets::Shape::Point]
+      def shape_point(...)
+        Widgets::Shape::Point.new(...)
+      end
+
+      # Creates a circle shape for Canvas.
+      # @return [Widgets::Shape::Circle]
+      def shape_circle(...)
+        Widgets::Shape::Circle.new(...)
+      end
+
+      # Creates a rectangle shape for Canvas.
+      # @return [Widgets::Shape::Rectangle]
+      def shape_rectangle(...)
+        Widgets::Shape::Rectangle.new(...)
+      end
+    end
+  end
+end

data/lib/ratatui_ruby/tui/core.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+# SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+# SPDX-License-Identifier: AGPL-3.0-or-later
+
+module RatatuiRuby
+  class TUI
+    # Core terminal methods delegated to RatatuiRuby module.
+    #
+    # These are the fundamental operations for the render loop:
+    # drawing UI, polling events, and inspecting the buffer.
+    module Core
+      # Draws the given UI node tree to the terminal.
+      # @see RatatuiRuby.draw
+      def draw(tree = nil, &)
+        RatatuiRuby.draw(tree, &)
+      end
+
+      # Checks for user input.
+      # @see RatatuiRuby.poll_event
+      def poll_event(timeout: 0.016)
+        RatatuiRuby.poll_event(timeout:)
+      end
+
+      # Inspects the terminal buffer at specific coordinates.
+      # @see RatatuiRuby.get_cell_at
+      def get_cell_at(x, y)
+        RatatuiRuby.get_cell_at(x, y)
+      end
+
+      # Creates a Draw::CellCmd for placing a cell at coordinates.
+      # @return [Draw::CellCmd]
+      def draw_cell(x, y, cell)
+        Draw.cell(x, y, cell)
+      end
+    end
+  end
+end

data/lib/ratatui_ruby/tui/layout_factories.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+# SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+# SPDX-License-Identifier: AGPL-3.0-or-later
+
+module RatatuiRuby
+  class TUI
+    # Layout factory methods for Session.
+    #
+    # Provides convenient access to Layout::Rect, Layout::Constraint,
+    # and Layout::Layout without fully qualifying the class names.
+    module LayoutFactories
+      # Creates a Layout::Rect.
+      # @return [Layout::Rect]
+      def rect(...)
+        Layout::Rect.new(...)
+      end
+
+      # Creates a Layout::Constraint.
+      # @return [Layout::Constraint]
+      def constraint(...)
+        Layout::Constraint.new(...)
+      end
+
+      # Creates a Layout::Constraint.length.
+      # @return [Layout::Constraint]
+      def constraint_length(n)
+        Layout::Constraint.length(n)
+      end
+
+      # Creates a Layout::Constraint.percentage.
+      # @return [Layout::Constraint]
+      def constraint_percentage(n)
+        Layout::Constraint.percentage(n)
+      end
+
+      # Creates a Layout::Constraint.min.
+      # @return [Layout::Constraint]
+      def constraint_min(n)
+        Layout::Constraint.min(n)
+      end
+
+      # Creates a Layout::Constraint.max.
+      # @return [Layout::Constraint]
+      def constraint_max(n)
+        Layout::Constraint.max(n)
+      end
+
+      # Creates a Layout::Constraint.fill.
+      # @return [Layout::Constraint]
+      def constraint_fill(n = 1)
+        Layout::Constraint.fill(n)
+      end
+
+      # Creates a Layout::Constraint.ratio.
+      # @return [Layout::Constraint]
+      def constraint_ratio(numerator, denominator)
+        Layout::Constraint.ratio(numerator, denominator)
+      end
+
+      # Creates a Layout::Layout.
+      # @return [Layout::Layout]
+      def layout(...)
+        Layout::Layout.new(...)
+      end
+
+      # Splits an area using Layout::Layout.split.
+      # @return [Array<Layout::Rect>]
+      def layout_split(area, direction: :vertical, constraints:, flex: :legacy)
+        Layout::Layout.split(area, direction:, constraints:, flex:)
+      end
+    end
+  end
+end