ratatui_ruby 0.9.1 → 0.10.1

data/lib/ratatui_ruby/widgets/bar_chart.rb

@@ -41,6 +41,8 @@ module RatatuiRuby
     # SPDX-SnippetEnd
     #++
     class BarChart < Data.define(:data, :bar_width, :bar_gap, :group_gap, :max, :style, :block, :direction, :label_style, :value_style, :bar_set)
+      include CoerceableWidget
+
       ##
       ##
       ##
@@ -215,19 +217,25 @@ module RatatuiRuby
       # SPDX-SnippetEnd
       #++
       def initialize(data:, bar_width: 3, bar_gap: 1, group_gap: 0, max: nil, style: nil, block: nil, direction: :vertical, label_style: nil, value_style: nil, bar_set: nil)
-        if bar_set && !bar_set.is_a?(Symbol)
-          if bar_set.is_a?(Array) && bar_set.size == 9
-            # Convert Array to Hash using BAR_KEYS order
-            bar_set = BAR_KEYS.zip(bar_set).to_h
-          else
-            bar_set = bar_set.dup
-            # Normalize numeric keys (0-8) to symbolic keys
-            BAR_KEYS.each_with_index do |key, i|
-              if (val = bar_set.delete(i) || bar_set.delete(i.to_s))
-                bar_set[key] = val
-              end
-            end
-          end
+        # Normalize bar_set to Hash[Symbol, String] if provided as Array or Hash
+        bar_set = case bar_set
+                  when Symbol, nil
+                    bar_set
+                  when Array
+                    # Convert Array to Hash using BAR_KEYS order
+                    BAR_KEYS.zip(bar_set).to_h
+                  when Hash
+                    # @type var raw_hash: Hash[untyped, untyped]
+                    raw_hash = bar_set.dup
+                    normalized = {} #: Hash[Symbol, String]
+                    # Normalize numeric keys (0-8) to symbolic keys
+                    BAR_KEYS.each_with_index do |key, i|
+                      val = raw_hash.delete(i) || raw_hash.delete(i.to_s) || raw_hash.delete(key)
+                      normalized[key] = val.to_s if val
+                    end
+                    normalized
+                  else
+                    bar_set
         end
 
         # Normalize data to Array of BarGroup
@@ -248,12 +256,13 @@ module RatatuiRuby
           elsif data.first.is_a?(BarGroup)
             data
           elsif data.first.is_a?(Array)
-            # Tuples
+            # Tuples - use type assertion for Steep
             if direction == :horizontal
               bars = data.map do |item|
-                label = item[0].to_s
-                value = item[1]
-                style = item[2]
+                tuple = item #: Array[untyped]
+                label = tuple[0].to_s
+                value = tuple[1]
+                style = tuple[2]
 
                 bar = Bar.new(value:, label:)
                 bar = bar.with(style:) if style
@@ -262,9 +271,10 @@ module RatatuiRuby
               [BarGroup.new(label: "", bars:)]
             else
               data.map do |item|
-                label = item[0].to_s
-                value = item[1]
-                style = item[2]
+                tuple = item #: Array[untyped]
+                label = tuple[0].to_s
+                value = tuple[1]
+                style = tuple[2]
 
                 bar = Bar.new(value:)
                 bar = bar.with(style:) if style

data/lib/ratatui_ruby/widgets/block.rb

@@ -23,6 +23,8 @@ module RatatuiRuby
     #
     #   ruby examples/widget_box/app.rb
     class Block < Data.define(:title, :titles, :title_alignment, :title_style, :borders, :border_style, :border_type, :border_set, :style, :padding, :children)
+      include CoerceableWidget
+
       ##
       # :attr_reader: title
       # The main title displayed on the top border.
@@ -170,8 +172,8 @@ module RatatuiRuby
         if border_set
           border_set = border_set.dup
           %i[top_left top_right bottom_left bottom_right vertical_left vertical_right horizontal_top horizontal_bottom].each do |long_key|
-            short_key = long_key.to_s.split("_").map { |s| s[0] }.join
-            if (val = border_set.delete(short_key.to_sym) || border_set.delete(short_key))
+            short_key = long_key.to_s.split("_").map { |s| s[0] }.join.to_sym
+            if (val = border_set.delete(short_key))
               border_set[long_key] = val
             end
           end
@@ -237,12 +239,18 @@ module RatatuiRuby
         top_border = has_border.call(:top) ? 1 : 0
         bottom_border = has_border.call(:bottom) ? 1 : 0
 
-        # Calculate padding offsets
-        if padding.is_a?(Array)
+        # Calculate padding offsets - ensure all are Integer
+        pad_left, pad_right, pad_top, pad_bottom = if padding.is_a?(Array)
           # [left, right, top, bottom]
-          pad_left, pad_right, pad_top, pad_bottom = padding
+          [
+            Integer(padding[0] || 0),
+            Integer(padding[1] || 0),
+            Integer(padding[2] || 0),
+            Integer(padding[3] || 0),
+          ]
         else
-          pad_left = pad_right = pad_top = pad_bottom = padding
+          p = Integer(padding)
+          [p, p, p, p]
         end
 
         # Compute inner area

data/lib/ratatui_ruby/widgets/calendar.rb

@@ -24,6 +24,8 @@ module RatatuiRuby
     #
     #   ruby examples/widget_calendar/app.rb
     class Calendar < Data.define(:year, :month, :events, :default_style, :header_style, :block, :show_weekdays_header, :show_surrounding, :show_month_header)
+      include CoerceableWidget
+
       ##
       # :attr_reader: year
       # The year to display (Integer).

data/lib/ratatui_ruby/widgets/canvas.rb

@@ -190,6 +190,8 @@ module RatatuiRuby
     # SPDX-SnippetEnd
     #++
     class Canvas < Data.define(:shapes, :x_bounds, :y_bounds, :marker, :block, :background_color)
+      include CoerceableWidget
+
       ##
       # :attr_reader: shapes
       # Array of shapes to render.
@@ -236,6 +238,60 @@ module RatatuiRuby
           background_color:
         )
       end
+
+      # Converts canvas coordinates to normalized grid coordinates.
+      #
+      # Hit testing and layout decisions need to know where a canvas point
+      # falls within the drawing surface. This method maps from the canvas
+      # coordinate system to normalized [0.0, 1.0] coordinates.
+      #
+      # Use it to determine if a click or touch event lands within the
+      # canvas bounds, and where proportionally.
+      #
+      # [x] X coordinate in canvas coordinate system.
+      # [y] Y coordinate in canvas coordinate system.
+      #
+      # Returns an Array <tt>[normalized_x, normalized_y]</tt> where each
+      # value is between 0.0 and 1.0, or <tt>nil</tt> if the point is
+      # outside the canvas bounds.
+      #
+      # === Example
+      #
+      #--
+      # SPDX-SnippetBegin
+      # SPDX-FileCopyrightText: 2026 Kerrick Long
+      # SPDX-License-Identifier: MIT-0
+      #++
+      #   canvas = Canvas.new(x_bounds: [0.0, 100.0], y_bounds: [0.0, 50.0])
+      #   canvas.get_point(50.0, 25.0)  # => [0.5, 0.5] (center)
+      #   canvas.get_point(0.0, 0.0)    # => [0.0, 1.0] (bottom-left)
+      #   canvas.get_point(101.0, 0.0)  # => nil (out of bounds)
+      #--
+      # SPDX-SnippetEnd
+      #++
+      def get_point(x, y)
+        left, right = x_bounds
+        bottom, top = y_bounds
+
+        # Check bounds
+        return nil if x < left || x > right || y < bottom || y > top
+
+        width = right - left
+        height = top - bottom
+
+        # Avoid division by zero
+        return nil if width <= 0.0 || height <= 0.0
+
+        # Normalize to [0.0, 1.0] range
+        normalized_x = (x - left) / width
+        normalized_y = (top - y) / height # Y inverted: top is 0, bottom is 1
+
+        [normalized_x, normalized_y]
+      end
+
+      # Ruby-idiomatic aliases (TIMTOWTDI)
+      alias point get_point
+      alias [] get_point
     end
   end
 end

data/lib/ratatui_ruby/widgets/cell.rb

@@ -37,6 +37,8 @@ module RatatuiRuby
     # SPDX-SnippetEnd
     #++
     class Cell < Data.define(:content, :style)
+      include CoerceableWidget
+
       ##
       # :attr_reader: content
       # The content to display (String, Text::Span, or Text::Line).

data/lib/ratatui_ruby/widgets/center.rb

@@ -33,6 +33,8 @@ module RatatuiRuby
     # SPDX-SnippetEnd
     #++
     class Center < Data.define(:child, :width_percent, :height_percent)
+      include CoerceableWidget
+
       ##
       # :attr_reader: child
       # The widget to be centered.

data/lib/ratatui_ruby/widgets/chart.rb

@@ -14,6 +14,8 @@ module RatatuiRuby
     # [style] Style
     # [labels_alignment] Symbol (<tt>:left</tt>, <tt>:center</tt>, <tt>:right</tt>)
     class Axis < Data.define(:title, :bounds, :labels, :style, :labels_alignment)
+      include CoerceableWidget
+
       ##
       # :attr_reader: title
       # Label for the axis (String).
@@ -59,6 +61,8 @@ module RatatuiRuby
     # [marker] Symbol (<tt>:dot</tt>, <tt>:braille</tt>, <tt>:block</tt>, <tt>:bar</tt>, <tt>:half_block</tt>)
     # [graph_type] Symbol (<tt>:line</tt>, <tt>:scatter</tt>)
     class Dataset < Data.define(:name, :data, :style, :marker, :graph_type)
+      include CoerceableWidget
+
       ##
       # :attr_reader: name
       # Name for logical identification or legend.
@@ -118,6 +122,8 @@ module RatatuiRuby
     #
     #   ruby examples/widget_chart/app.rb
     class Chart < Data.define(:datasets, :x_axis, :y_axis, :block, :style, :legend_position, :hidden_legend_constraints)
+      include CoerceableWidget
+
       ##
       # :attr_reader: datasets
       # Array of Dataset objects to plot.

data/lib/ratatui_ruby/widgets/clear.rb

@@ -46,6 +46,8 @@ module RatatuiRuby
     # SPDX-SnippetEnd
     #++
     class Clear < Data.define(:block)
+      include CoerceableWidget
+
       ##
       # :attr_reader: block
       # Optional Block to render after clearing.

data/lib/ratatui_ruby/widgets/coerceable_widget.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+#--
+# SPDX-FileCopyrightText: 2026 Kerrick Long <me@kerricklong.com>
+# SPDX-License-Identifier: LGPL-3.0-or-later
+#++
+
+module RatatuiRuby
+  module Widgets
+    # Mixin that provides DWIM hash coercion for widget classes.
+    #
+    # When users call `tui.table(hash)` instead of `tui.table(**hash)`,
+    # Ruby's `...` forwarding passes the Hash as a positional argument,
+    # causing cryptic TypeErrors at the Rust FFI boundary.
+    #
+    # This mixin provides a `coerce_args` class method that detects
+    # this pattern and automatically splats the hash into keyword arguments.
+    #
+    # === Behavior
+    #
+    # - **Production mode**: Unknown keys are silently ignored
+    # - **Debug mode (RR_DEBUG=1)**: Raises ArgumentError to catch typos early
+    #
+    # === Usage
+    #
+    #--
+    # SPDX-SnippetBegin
+    # SPDX-FileCopyrightText: 2026 Kerrick Long
+    # SPDX-License-Identifier: MIT-0
+    #++
+    #   class Table < Data.define(:rows, :widths, ...)
+    #     include CoerceableWidget
+    #   end
+    #
+    #   # In WidgetFactories:
+    #   def table(first = nil, **kwargs)
+    #     Widgets::Table.coerce_args(first, kwargs)
+    #   end
+    #--
+    # SPDX-SnippetEnd
+    #++
+    module CoerceableWidget
+      ##
+      # Hook called when this module is included in a widget class.
+      #
+      # Extends the class with ClassMethods and defines KNOWN_KEYS constant
+      # from the Data.define members for validation.
+      #
+      # [base] The class including this module.
+      def self.included(base)
+        base.extend(ClassMethods)
+        base.const_set(:KNOWN_KEYS, base.members.freeze) unless base.const_defined?(:KNOWN_KEYS)
+      end
+
+      # Class methods extended onto widget classes.
+      module ClassMethods
+        # Coerces a bare Hash argument into keyword arguments.
+        #
+        # @param first [Hash, nil] First positional argument (bare hash case)
+        # @param kwargs [Hash] Keyword arguments (normal splatted case)
+        # @return [Object] New instance of the widget class
+        # @raise [ArgumentError] In debug mode, if unknown keys are present
+        def coerce_args(first, kwargs)
+          if first.is_a?(Hash) && kwargs.empty?
+            unknown = first.keys - self::KNOWN_KEYS
+            if unknown.any? && RatatuiRuby::Debug.enabled?
+              raise ArgumentError, "#{name}: unknown keys #{unknown.inspect}"
+            end
+            new(**first.slice(*self::KNOWN_KEYS))
+          else
+            new(**kwargs)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ratatui_ruby/widgets/cursor.rb

@@ -32,6 +32,8 @@ module RatatuiRuby
     # - {Component-based implementation using Frame API}[link:/examples/app_color_picker/app_rb.html]
     # - RatatuiRuby::Frame#set_cursor_position (Frame API alternative)
     class Cursor < Data.define(:x, :y)
+      include CoerceableWidget
+
       ##
       # :attr_reader: x
       # X coordinate (column).

data/lib/ratatui_ruby/widgets/gauge.rb

@@ -23,6 +23,8 @@ module RatatuiRuby
     #
     #   ruby examples/widget_gauge/app.rb
     class Gauge < Data.define(:ratio, :label, :style, :gauge_style, :block, :use_unicode)
+      include CoerceableWidget
+
       ##
       # :attr_reader: ratio
       # Progress ratio from 0.0 to 1.0.
@@ -62,9 +64,16 @@ module RatatuiRuby
       # [gauge_style] Style object for the filled bar (optional).
       # [block] Block widget (optional).
       # [use_unicode] Boolean (default: true).
+      #
+      # Raises ArgumentError if percent is not 0..100.
       def initialize(ratio: nil, percent: nil, label: nil, style: nil, gauge_style: nil, block: nil, use_unicode: true)
         if percent
-          ratio = Float(percent) / 100.0
+          float_percent = Float(percent)
+          unless float_percent.between?(0, 100)
+            raise ArgumentError, "percent must be between 0 and 100 (got #{percent.inspect})"
+          end
+          # Float(Numeric) incorrectly returns Float? -- https://github.com/ruby/rbs/issues/2793
+          ratio = float_percent / 100.0 #: Float
         end
         ratio = Float(ratio || 0.0)
         super(ratio:, label:, style:, gauge_style:, block:, use_unicode:)
@@ -72,17 +81,66 @@ module RatatuiRuby
 
       # Returns true if the gauge has any fill (ratio > 0).
       #
-      # @return [Boolean]
+      # === Example
+      #
+      #--
+      # SPDX-SnippetBegin
+      # SPDX-FileCopyrightText: 2026 Kerrick Long
+      # SPDX-License-Identifier: MIT-0
+      #++
+      #   Widgets::Gauge.new(ratio: 0.0).filled?  # => false
+      #   Widgets::Gauge.new(ratio: 0.5).filled?  # => true
+      #--
+      # SPDX-SnippetEnd
+      #++
       def filled?
         ratio > 0
       end
 
       # Returns true if the gauge is at 100% or more (ratio >= 1.0).
       #
-      # @return [Boolean]
+      # === Example
+      #
+      #--
+      # SPDX-SnippetBegin
+      # SPDX-FileCopyrightText: 2026 Kerrick Long
+      # SPDX-License-Identifier: MIT-0
+      #++
+      #   Widgets::Gauge.new(ratio: 0.99).complete?  # => false
+      #   Widgets::Gauge.new(ratio: 1.0).complete?   # => true
+      #--
+      # SPDX-SnippetEnd
+      #++
       def complete?
         ratio >= 1.0
       end
+
+      # Returns the progress as an integer percentage (0-100).
+      #
+      # Gauge stores progress as a ratio (0.0 to 1.0). User-facing code often
+      # displays percentages. Converting manually is tedious.
+      #
+      # This is the inverse of passing <tt>percent:</tt> to the constructor.
+      # Rounds down to the nearest integer.
+      #
+      # === Example
+      #
+      #--
+      # SPDX-SnippetBegin
+      # SPDX-FileCopyrightText: 2026 Kerrick Long
+      # SPDX-License-Identifier: MIT-0
+      #++
+      #   gauge = Widgets::Gauge.new(percent: 75)
+      #   gauge.percent  # => 75
+      #
+      #   gauge = Widgets::Gauge.new(ratio: 0.456)
+      #   gauge.percent  # => 45
+      #--
+      # SPDX-SnippetEnd
+      #++
+      def percent
+        (ratio * 100).to_i
+      end
     end
   end
 end

data/lib/ratatui_ruby/widgets/line_gauge.rb

@@ -23,6 +23,8 @@ module RatatuiRuby
     #
     #   ruby examples/widget_line_gauge/app.rb
     class LineGauge < Data.define(:ratio, :label, :style, :filled_style, :unfilled_style, :block, :filled_symbol, :unfilled_symbol)
+      include CoerceableWidget
+
       ##
       # :attr_reader: ratio
       # Progress ratio from 0.0 to 1.0.
@@ -58,6 +60,7 @@ module RatatuiRuby
       # Creates a new LineGauge.
       #
       # [ratio] Float (0.0 - 1.0).
+      # [percent] Integer (0 - 100), alternative to ratio.
       # [label] String or Text::Span (optional).
       # [style] Style (optional, base style for the gauge).
       # [filled_style] Style.
@@ -65,9 +68,19 @@ module RatatuiRuby
       # [block] Block.
       # [filled_symbol] String (default: <tt>"█"</tt>).
       # [unfilled_symbol] String (default: <tt>"░"</tt>).
-      def initialize(ratio: 0.0, label: nil, style: nil, filled_style: nil, unfilled_style: nil, block: nil, filled_symbol: "█", unfilled_symbol: "░")
+      #
+      # Raises ArgumentError if percent is not 0..100.
+      def initialize(ratio: nil, percent: nil, label: nil, style: nil, filled_style: nil, unfilled_style: nil, block: nil, filled_symbol: "█", unfilled_symbol: "░")
+        if percent
+          float_percent = Float(percent)
+          unless float_percent.between?(0, 100)
+            raise ArgumentError, "percent must be between 0 and 100 (got #{percent.inspect})"
+          end
+          ratio = float_percent / 100.0
+        end
+        ratio = Float(ratio || 0.0)
         super(
-          ratio: Float(ratio),
+          ratio:,
           label:,
           style:,
           filled_style:,
@@ -80,17 +93,66 @@ module RatatuiRuby
 
       # Returns true if the gauge has any fill (ratio > 0).
       #
-      # @return [Boolean]
+      # === Example
+      #
+      #--
+      # SPDX-SnippetBegin
+      # SPDX-FileCopyrightText: 2026 Kerrick Long
+      # SPDX-License-Identifier: MIT-0
+      #++
+      #   Widgets::LineGauge.new(ratio: 0.0).filled?  # => false
+      #   Widgets::LineGauge.new(ratio: 0.5).filled?  # => true
+      #--
+      # SPDX-SnippetEnd
+      #++
       def filled?
         ratio > 0
       end
 
       # Returns true if the gauge is at 100% or more (ratio >= 1.0).
       #
-      # @return [Boolean]
+      # === Example
+      #
+      #--
+      # SPDX-SnippetBegin
+      # SPDX-FileCopyrightText: 2026 Kerrick Long
+      # SPDX-License-Identifier: MIT-0
+      #++
+      #   Widgets::LineGauge.new(ratio: 0.99).complete?  # => false
+      #   Widgets::LineGauge.new(ratio: 1.0).complete?   # => true
+      #--
+      # SPDX-SnippetEnd
+      #++
       def complete?
         ratio >= 1.0
       end
+
+      # Returns the progress as an integer percentage (0-100).
+      #
+      # LineGauge stores progress as a ratio (0.0 to 1.0). User-facing code often
+      # displays percentages. Converting manually is tedious.
+      #
+      # This is the inverse of passing <tt>percent:</tt> to the constructor.
+      # Rounds down to the nearest integer.
+      #
+      # === Example
+      #
+      #--
+      # SPDX-SnippetBegin
+      # SPDX-FileCopyrightText: 2026 Kerrick Long
+      # SPDX-License-Identifier: MIT-0
+      #++
+      #   lg = Widgets::LineGauge.new(percent: 75)
+      #   lg.percent  # => 75
+      #
+      #   lg = Widgets::LineGauge.new(ratio: 0.456)
+      #   lg.percent  # => 45
+      #--
+      # SPDX-SnippetEnd
+      #++
+      def percent
+        (ratio * 100).to_i
+      end
     end
   end
 end

data/lib/ratatui_ruby/widgets/list.rb

@@ -39,6 +39,8 @@ module RatatuiRuby
     # SPDX-SnippetEnd
     #++
     class List < Data.define(:items, :selected_index, :offset, :style, :highlight_style, :highlight_symbol, :repeat_highlight_symbol, :highlight_spacing, :direction, :scroll_padding, :block)
+      include CoerceableWidget
+
       ##
       # Highlight spacing: always show the spacing column.
       HIGHLIGHT_ALWAYS = :always
@@ -152,17 +154,99 @@ module RatatuiRuby
 
       # Returns true if an item is selected.
       #
-      # @return [Boolean]
+      # === Example
+      #
+      #--
+      # SPDX-SnippetBegin
+      # SPDX-FileCopyrightText: 2026 Kerrick Long
+      # SPDX-License-Identifier: MIT-0
+      #++
+      #   list = Widgets::List.new(items: %w[a b c])
+      #   list.selected?  # => false
+      #
+      #   list = Widgets::List.new(items: %w[a b c], selected_index: 1)
+      #   list.selected?  # => true
+      #
+      #--
+      # SPDX-SnippetEnd
+      #++
+      # Returns: Boolean.
       def selected?
         !selected_index.nil?
       end
 
-      # Returns true if the list has no items.
+      # Returns true if the list contains no items.
+      #
+      # === Example
       #
-      # @return [Boolean]
+      #--
+      # SPDX-SnippetBegin
+      # SPDX-FileCopyrightText: 2026 Kerrick Long
+      # SPDX-License-Identifier: MIT-0
+      #++
+      #   list = Widgets::List.new(items: [])
+      #   list.empty?  # => true
+      #
+      #--
+      # SPDX-SnippetEnd
+      #++
+      # Returns: Boolean.
       def empty?
         items.empty?
       end
+
+      # Returns the number of items in the list.
+      #
+      # === Example
+      #
+      #--
+      # SPDX-SnippetBegin
+      # SPDX-FileCopyrightText: 2026 Kerrick Long
+      # SPDX-License-Identifier: MIT-0
+      #++
+      #   list = Widgets::List.new(items: %w[alpha beta gamma])
+      #   list.len  # => 3
+      #
+      #--
+      # SPDX-SnippetEnd
+      #++
+      # Returns: Integer.
+      def len
+        items.length
+      end
+
+      alias length len
+      alias size len
+
+      # NOTE: No 'selection' alias - it's ambiguous whether it returns an item or index.
+      # Use selected_index for the index, selected_item for the item.
+
+      # Returns the currently selected item, or nil if nothing is selected.
+      #
+      # Accessing the selected item directly requires looking up +items[selected_index]+
+      # after checking that +selected_index+ is not nil. This is verbose.
+      #
+      # This method encapsulates that pattern.
+      #
+      # === Example
+      #
+      #--
+      # SPDX-SnippetBegin
+      # SPDX-FileCopyrightText: 2026 Kerrick Long
+      # SPDX-License-Identifier: MIT-0
+      #++
+      #   list = Widgets::List.new(items: %w[alpha beta gamma], selected_index: 1)
+      #   list.selected_item  # => "beta"
+      #
+      #--
+      # SPDX-SnippetEnd
+      #++
+      # Returns: The item at the selected index, or nil if no selection.
+      def selected_item
+        return nil if selected_index.nil?
+
+        items[selected_index]
+      end
     end
   end
 end

data/lib/ratatui_ruby/widgets/list_item.rb

@@ -33,6 +33,8 @@ module RatatuiRuby
     # SPDX-SnippetEnd
     #++
     class ListItem < Data.define(:content, :style)
+      include CoerceableWidget
+
       ##
       # :attr_reader: content
       # The content to display (String, Text::Span, or Text::Line).

data/lib/ratatui_ruby/widgets/overlay.rb

@@ -35,6 +35,8 @@ module RatatuiRuby
     # SPDX-SnippetEnd
     #++
     class Overlay < Data.define(:layers)
+      include CoerceableWidget
+
       ##
       # :attr_reader: layers
       # The stack of widgets to render.