tuile 0.10.0 → 0.11.0

data/lib/tuile/component/layout.rb

@@ -3,7 +3,13 @@
 module Tuile
   class Component
     # A layout doesn't paint anything by itself: its job is to position child
-    # components.
+    # components. Two families, both top-down (see book ch3):
+    #
+    # - {Absolute} — you override {Component#rect=} and compute every child's
+    #   rectangle yourself. Total control, and the base for anything unusual.
+    # - {Box} / {Vertical} / {Horizontal} — you declare each child's extent as
+    #   a {Fixed}, {Percent} or {Expand} constraint and the layout does the
+    #   arithmetic. Sugar over the same `rect=` assignment, for the common case.
     #
     # Children that fully tile the layout's rect repaint themselves and
     # cover everything; children that leave gaps (e.g. a form with widgets
@@ -11,6 +17,148 @@ module Tuile
     # the background is cleared and children are re-invalidated so they
     # paint over a clean surface.
     class Layout < Component
+      # How much space a child gets along one axis of a {Box}: exactly {#cells},
+      # clamped to whatever is still unassigned.
+      #
+      #   add(prompt, Fixed[4])                    # 4 rows in a Vertical
+      #   add(field, Fixed[1], cross: Fixed[30])   # 1 row, 30 columns wide
+      #
+      # `Fixed[0]` hides the child — it gets an empty rect and paints nothing.
+      #
+      # @!attribute [r] cells
+      #   @return [Integer] cell count along the axis.
+      class Fixed < Data.define(:cells)
+        # @param cells [Integer] cell count along the axis; `>= 0`.
+        # @raise [ArgumentError] unless `cells` is a non-negative Integer.
+        def initialize(cells:)
+          unless cells.is_a?(Integer) && !cells.negative?
+            raise ArgumentError, "Fixed expects a non-negative Integer, got #{cells.inspect}"
+          end
+
+          super
+        end
+      end
+
+      # A percentage of the space *available* along a {Box}'s axis — measured
+      # after {Box#padding} and {Box#spacing} have come off, so two `Percent[50]`
+      # children fit exactly rather than overflowing by the gap between them.
+      #
+      #   add(left, Percent[60])
+      #   add(right, Percent[40])
+      #
+      # @!attribute [r] percent
+      #   @return [Numeric] percentage of the available extent, `0..100`.
+      class Percent < Data.define(:percent)
+        # @param percent [Numeric] percentage of the available extent, `0..100`.
+        # @raise [ArgumentError] unless `percent` is a Numeric in `0..100`.
+        def initialize(percent:)
+          unless percent.is_a?(Numeric) && percent.between?(0, 100)
+            raise ArgumentError, "Percent expects a Numeric in 0..100, got #{percent.inspect}"
+          end
+
+          super
+        end
+      end
+
+      # A share of whatever a {Box} has left once its {Fixed} and {Percent}
+      # children have taken theirs, split between the `Expand` children in
+      # proportion to their weights:
+      #
+      #   add(header, Fixed[1])
+      #   add(body, Expand[2])    # gets twice…
+      #   add(side, Expand[1])    # …what this one gets
+      #
+      # Main axis only — {Box#add} rejects one passed as `cross:`, where a child
+      # has no siblings to compete with and so nothing for a weight to mean.
+      #
+      # @!attribute [r] weight
+      #   @return [Integer] relative share of the leftover space.
+      class Expand < Data.define(:weight)
+        # @param weight [Integer] relative share; `>= 1`.
+        # @raise [ArgumentError] unless `weight` is a positive Integer.
+        def initialize(weight:)
+          unless weight.is_a?(Integer) && weight.positive?
+            raise ArgumentError, "Expand expects a positive Integer weight, got #{weight.inspect}"
+          end
+
+          super
+        end
+      end
+
+      # Per-edge padding for a {Box}, in cells:
+      #
+      #   Insets[top: 1]                     # one blank row above the children
+      #   Insets[top: 1, left: 2, right: 2]  # unnamed edges default to 0
+      #   Insets.coerce(1)                   # uniform on all four edges
+      #
+      # Keyword-only: AWT and JavaFX order these same four numbers differently,
+      # so a positional form would be a coin flip.
+      #
+      # @!attribute [r] top
+      #   @return [Integer] cells inset from the top edge.
+      # @!attribute [r] right
+      #   @return [Integer] cells inset from the right edge.
+      # @!attribute [r] bottom
+      #   @return [Integer] cells inset from the bottom edge.
+      # @!attribute [r] left
+      #   @return [Integer] cells inset from the left edge.
+      class Insets < Data.define(:top, :right, :bottom, :left)
+        # @param positional [Array] must be empty — see the class doc.
+        # @param kwargs [Hash{Symbol => Integer}] any of `top:`/`right:`/`bottom:`/`left:`.
+        # @raise [ArgumentError] if any positional argument is given.
+        # @return [Insets]
+        def self.new(*positional, **kwargs)
+          raise ArgumentError, "Insets is keyword-only, got #{positional.inspect}" unless positional.empty?
+
+          super(**kwargs)
+        end
+
+        # Needed because `Data`'s inherited `[]` never dispatches through a `new`
+        # override, so the guard above alone would miss `Insets[1, 2, 3, 4]`.
+        # @param positional [Array] must be empty.
+        # @param kwargs [Hash{Symbol => Integer}] any of `top:`/`right:`/`bottom:`/`left:`.
+        # @raise [ArgumentError] if any positional argument is given.
+        # @return [Insets]
+        def self.[](*positional, **kwargs) = new(*positional, **kwargs)
+
+        # @param value [Insets, Integer] an Integer becomes a uniform inset.
+        # @raise [ArgumentError] on anything else, or a negative Integer.
+        # @return [Insets]
+        def self.coerce(value)
+          return value if value.is_a?(Insets)
+          unless value.is_a?(Integer) && !value.negative?
+            raise ArgumentError, "expected Insets or a non-negative Integer, got #{value.inspect}"
+          end
+
+          new(top: value, right: value, bottom: value, left: value)
+        end
+
+        # @param top [Integer] cells inset from the top edge; `>= 0`.
+        # @param right [Integer] cells inset from the right edge; `>= 0`.
+        # @param bottom [Integer] cells inset from the bottom edge; `>= 0`.
+        # @param left [Integer] cells inset from the left edge; `>= 0`.
+        # @raise [ArgumentError] unless every edge is a non-negative Integer.
+        def initialize(top: 0, right: 0, bottom: 0, left: 0)
+          { top:, right:, bottom:, left: }.each do |edge, cells|
+            unless cells.is_a?(Integer) && !cells.negative?
+              raise ArgumentError, "Insets #{edge}: expected a non-negative Integer, got #{cells.inspect}"
+            end
+          end
+
+          super
+        end
+
+        # @return [Integer] `left` + `right`.
+        def horizontal = left + right
+
+        # @return [Integer] `top` + `bottom`.
+        def vertical = top + bottom
+
+        # No padding on any edge.
+        # @return [Insets]
+        ZERO = new
+      end
+
       # Layouts are focusable containers — like {Window} and {Popup}, they
       # don't accept input themselves but they need to participate in the
       # {HasContent} focus cascade so a Popup wrapping a Layout wrapping a

data/lib/tuile/component/list_dropdown.rb

@@ -3,26 +3,27 @@
 module Tuile
   class Component
     # A borderless, tinted, non-focusable floating selection list — the dropdown
-    # a text input drops open, drives by forwarding movement keys, and commits a
+    # a *driver* drops open, drives by forwarding movement keys, and commits a
     # pick from: a non-modal {Popup} wrapping a {List} that never takes focus, so
-    # the caret stays in the driving input while the caller refills the rows,
-    # moves the highlight, and reads the pick.
+    # focus stays on the driver while the caller refills the rows, moves the
+    # highlight, and reads the pick.
     #
     #   drop = Component::ListDropdown.new
     #   drop.on_item_chosen = ->(index, _line) { commit(index) } # caller commits
-    #   # …then, per keystroke in the driving input's key handler:
-    #   drop.lines = matches.map { |m| render(m) }  # caller filters + renders
-    #   drop.rect  = Rect.new(...)                   # caller anchors + sizes it
+    #   # …then, from the driver's key handler:
+    #   drop.lines = matches.map { |m| render(m) }   # caller filters + renders
+    #   drop.anchor_to(rect, rows: matches.size)     # below the driver, or flipped
     #   drop.open
     #   return true if drop.move(key)  # Up/Down/PgUp/PgDn/^U/^D → list scroll
     #   drop.choose if key == Keys::ENTER            # commit the highlight
     #
-    # It owns only what every such dropdown shares; everything that varies stays
-    # with the driver: geometry/anchoring, filtering, row rendering, the commit
-    # action, and ESC/Enter handling. ESC and Enter carry driver-specific tails
-    # (ESC may revert a query; Enter may commit via {#choose} *or* via a separate
-    # submit path), so {#move} claims neither — the driver calls {#choose} and
-    # {#close} from its own branches.
+    # It owns only what every such dropdown shares — *placement* included, via
+    # {#anchor_to}. What stays with the driver: the width **policy** ({#anchor_to}
+    # measures nothing itself), filtering, row rendering, the commit action, and
+    # ESC/Enter handling. ESC and Enter carry driver-specific tails (ESC may
+    # revert a query; Enter may commit via {#choose} *or* via a separate submit
+    # path), so {#move} claims neither — the driver calls {#choose} and {#close}
+    # from its own branches.
     #
     # == Theming
     # Borderless, told apart from the content beneath by a background tint —
@@ -33,8 +34,8 @@ module Tuile
     # UI-thread-confined, like every component (see {Screen}).
     class ListDropdown < Popup
       # The dropdown's {List}. Non-focusable on purpose: the driver forwards keys
-      # while focus (and the caret) stay in its input, and a mouse click selects
-      # an item without stealing focus — so the input never loses the cursor
+      # while focus stays on it, and a mouse click selects an item without
+      # stealing focus — so a driving text input never loses its caret
       # mid-interaction.
       class Menu < List
         def focusable? = false
@@ -43,17 +44,24 @@ module Tuile
 
       # Cursor-movement keys forwarded to the list by {#move}: the two vertical
       # arrows, page up/down, and Ctrl+U/D half-page jumps. Deliberately excludes
-      # Home/End and `j`/`k` (they belong to the driving field — caret movement
-      # and typing) and Enter/ESC (they carry driver-specific tails — see the
-      # class docs).
+      # Home/End and `j`/`k` — a jump to the first/last row is the driver's call,
+      # and both drivers decline it ({ComboBox}'s field needs Home/End for the
+      # caret; {Select} would spend a branch on what a second arrow press already
+      # does) — and Enter/ESC, which carry driver-specific tails (see the class
+      # docs).
       # @return [Array<String>]
       MOVE_KEYS = [Keys::UP_ARROW, Keys::DOWN_ARROW, Keys::PAGE_UP, Keys::PAGE_DOWN,
                    Keys::CTRL_U, Keys::CTRL_D].freeze
 
+      # Most rows shown before the list scrolls; {#anchor_to}'s `max_rows`
+      # default.
+      # @return [Integer]
+      MAX_VISIBLE_ROWS = 10
+
       def initialize
         @list = Menu.new
         @list.cursor = List::Cursor.new
-        @list.show_cursor_when_inactive = true # highlight the selection though focus stays in the input
+        @list.show_cursor_when_inactive = true # highlight the selection though focus stays on the driver
         super(content: @list, modal: false)
         self.bg_color = Theme.ref(:input_bg_color)
       end
@@ -82,6 +90,49 @@ module Tuile
       # @return [List::Cursor] the list's cursor (the current highlight).
       def cursor = @list.cursor
 
+      # Sizes and places the dropdown against `anchor`: directly beneath it,
+      # flipped above when `rows` won't fit below, clamped — with the list
+      # scrolling — when neither side has room. Horizontally the left edges line
+      # up, sliding left only far enough to keep the panel on screen.
+      #
+      #   drop.anchor_to(field.rect, rows: matches.size)            # field width
+      #   drop.anchor_to(rect, rows: items.size, width: measured)   # own width
+      #
+      # Vertical flips but horizontal slides because covering the driver would
+      # hide what is being chosen, while sharing its columns is the point.
+      #
+      # @param anchor [Rect] the driver's rect; the dropdown never covers it.
+      # @param rows [Integer] how many rows there are to show — the content
+      #   count, not the height: more than fits turns the scrollbar on. `0`
+      #   collapses the dropdown to an empty rect (drivers close instead).
+      # @param width [Integer] the panel's width in columns, clamped to the
+      #   screen. Defaults to the anchor's, which lines both edges up with a
+      #   field; a driver that measured its labels passes its own. A label wider
+      #   than the screen clips — {List} has no horizontal scrolling.
+      # @param max_rows [Integer] rows shown before the list scrolls.
+      # @return [void]
+      def anchor_to(anchor, rows:, width: anchor.width, max_rows: MAX_VISIBLE_ROWS)
+        desired = [rows, max_rows].min
+        below = screen.size.height - (anchor.top + 1)
+        above = anchor.top
+        if desired <= below
+          top = anchor.top + 1
+          height = desired
+        elsif above >= below
+          height = [desired, above].min
+          top = anchor.top - height
+        else
+          height = below
+          top = anchor.top + 1
+        end
+        width = [width, screen.size.width].min
+        self.size = Size.new(width, height)
+        self.rect = Rect.new([anchor.left, screen.size.width - width].min.clamp(0, nil), top, width, height)
+        # After the geometry: the setter rebuilds the list's padded rows against
+        # the width it can see, and the gutter takes a column off it.
+        @list.scrollbar_visibility = rows > height ? :visible : :gone
+      end
+
       # Forwards a cursor-movement key to the list. The driver calls this from
       # its own key handler; a truthy return means "consumed — stop here", falsy
       # means "not mine — proceed with normal editing/dispatch". Only {MOVE_KEYS}

data/lib/tuile/component/select.rb

@@ -0,0 +1,251 @@
+# frozen_string_literal: true
+
+module Tuile
+  class Component
+    # A closed-choice field on one row: the selected item's label plus a `▾`
+    # affordance, dropping open a {ListDropdown} of the options. Enter, Space or
+    # Down opens it; the arrows (and PgUp/PgDn) move the highlight; Enter or
+    # Space commits; ESC dismisses without committing.
+    #
+    #   warn                ▾     <- the face: one row, on a field well
+    #    debug                    <- the dropdown, measured to the widest label
+    #    info                        (the one-column gutters are {List}'s)
+    #    warn                     <- highlighted: the value's row, on open
+    #    error
+    #
+    #   sel = Component::Select.new(items: LogLevel.all)
+    #   sel.item_label = ->(l) { l.name }          # item -> shown label; default :to_s
+    #   sel.on_value_change = ->(l) { relog(l) }   # fires on commit, with the item
+    #   sel.value = LogLevel::WARN                 # selects it; the face shows its label
+    #
+    # Use it for an **enum** — labels the developer authored, a closed set known
+    # when the code is written: log level, sort order, line endings, Yes/No/Ask.
+    # For items the app supplies at runtime with labels you don't control
+    # (countries, users, branches) reach for {ComboBox} instead, where filtering
+    # is the navigation. Item count is a symptom, not the criterion; book ch7 has
+    # the widget-choice table.
+    #
+    # {#value} is the selected *item*, of whatever type {#items} holds, never its
+    # label; `nil` — a blank face — is the initial state and stays legal, so an
+    # optional enum field needs no placeholder. As on {ComboBox}, {#items=} is
+    # chrome: it never touches {#value}, never fires {HasValue#on_value_change},
+    # and a value absent from {#items} survives intact while rendering nothing
+    # selected. Keeping the two in sync is the app's job.
+    #
+    # == It claims no printable key but Space
+    # Enter, Space, ESC, {ListDropdown::MOVE_KEYS} and the mouse. *Every other*
+    # printable key bubbles past it (key-dispatch rung 3), so a form's `s`-to-save
+    # and a layout's `1`/`2`/`3` pane jumps keep working while a Select has focus
+    # — the one capability no {ComboBox} configuration can offer, since a text
+    # field eats printables unconditionally. Space is the single exception, and it
+    # forecloses nothing: every activatable widget in the gem already claims it.
+    # Home/End are declined too, so they stay available app-wide.
+    #
+    # There is no type-ahead: a hidden prefix buffer *is* the ComboBox query with
+    # the feedback removed (`DECISIONS.md` `D-select`). Which is also why labels
+    # need no prefix-disambiguation.
+    #
+    # == Implementation details
+    # A leaf widget: it paints its own row (the face is *derived* from {#value}
+    # each paint, never a synced copy) and owns the dropdown as an overlay, which
+    # is not a child — like {ComboBox}'s. The well is read from
+    # {Screen#theme} at paint time, so it tracks a theme flip with no hook.
+    #
+    # The dropdown is at least as wide as the face and grows to fit the widest
+    # label, so the labels are never the thing that ellipsizes. It is not opened
+    # at all when {#items} is empty: an item-less Select is a programming bug, and
+    # an empty tinted panel reads as a broken list rather than as "nothing to
+    # pick". Enter/Space/Down are claimed either way.
+    #
+    # UI-thread-confined, like every component (see {Screen}).
+    class Select < Component
+      include HasValue
+
+      # @param items [Array] the options (any type); also settable via {#items=}.
+      # @param value [Object, nil] the initially selected item. Seeds the backing
+      #   ivar directly, so no listener fires and assignment order doesn't matter
+      #   to a form helper.
+      def initialize(items: [], value: nil)
+        super()
+        @items = items.to_a
+        @item_label = :to_s.to_proc
+        @value = value
+        @on_value_change = nil
+        @overlay = ListDropdown.new
+        @overlay.on_item_chosen = ->(index, _line) { commit(index) }
+      end
+
+      # @return [Array] the options.
+      attr_reader :items
+
+      # @return [Proc, Method] item -> shown label (a `String` or
+      #   {StyledString}); `:to_s` by default. Never called with `nil` — an
+      #   unselected Select renders a blank face.
+      attr_reader :item_label
+
+      def tab_stop? = true
+
+      # Replaces the options, leaving {#value} untouched. An open dropdown is
+      # rebuilt (and re-measured) around them, or closed when none are left.
+      # @param new_items [Array]
+      # @raise [TypeError] unless `new_items` is an `Array`.
+      # @return [void]
+      def items=(new_items)
+        raise TypeError, "expected Array, got #{new_items.inspect}" unless new_items.is_a?(Array)
+
+        @items = new_items
+        refill if @overlay.open?
+        invalidate
+      end
+
+      # @param proc [Proc, Method] item -> shown label.
+      # @return [void]
+      def item_label=(proc)
+        @item_label = proc
+        refill if @overlay.open?
+        invalidate
+      end
+
+      # @return [String]
+      def keyboard_hint = "⏎ #{screen.theme.hint("open")}  ↑↓ #{screen.theme.hint("select")}"
+
+      # Re-anchors the (open) dropdown after a move or resize.
+      # @param new_rect [Rect]
+      # @return [void]
+      def rect=(new_rect)
+        super
+        anchor if @overlay.open?
+      end
+
+      # Closes the dropdown when the Select leaves the focus chain, so tabbing
+      # away doesn't strand an open menu. Safe against re-entrancy: focus never
+      # sits inside the (non-focusable) {ListDropdown}, so closing it repairs no
+      # focus.
+      # @param flag [Boolean]
+      # @return [void]
+      def active=(flag)
+        was = active?
+        super
+        close_menu if was && !active?
+      end
+
+      # Opens the dropdown on Enter, Space or Down; while it is open, forwards
+      # {ListDropdown::MOVE_KEYS} to it, commits the highlight on Enter or Space,
+      # and dismisses on ESC. Everything else — every other printable included —
+      # is left unhandled so it bubbles to an ancestor.
+      # @param key [String]
+      # @return [Boolean]
+      def handle_key(key)
+        if @overlay.open?
+          return true if @overlay.move(key)
+
+          case key
+          when Keys::ENTER, " " then @overlay.choose
+          when Keys::ESC then close_menu
+          else return false
+          end
+          true
+        elsif [Keys::ENTER, " ", Keys::DOWN_ARROW].include?(key)
+          open_menu
+          true
+        else
+          false
+        end
+      end
+
+      # Toggles the dropdown on a left click anywhere in {#rect} — a field's
+      # affordance is its whole row, as the well advertises; `super` runs first,
+      # so the click also focuses.
+      # @param event [MouseEvent]
+      # @return [void]
+      def handle_mouse(event)
+        super
+        return unless event.button == :left && rect.contains?(event.point)
+
+        @overlay.open? ? close_menu : open_menu
+      end
+
+      # @return [void]
+      def repaint
+        return if rect.empty?
+
+        tail = Rect.new(rect.left, rect.top + 1, rect.width, rect.height - 1)
+        clear_background(tail) unless tail.empty?
+        draw_line(rect.left, rect.top, face_row)
+      end
+
+      private
+
+      # The painted row: the value's label padded across all but the last column,
+      # then the `▾`, all on the field well — {Theme#active_bg_color} while on the
+      # focus chain, {Theme#input_bg_color} otherwise.
+      # @return [StyledString]
+      def face_row
+        width = [rect.width - 1, 0].max
+        label = label_for(value).ellipsize(width)
+        row = label + StyledString.plain("#{" " * (width - label.display_width)}▾")
+        row.with_bg(active? ? screen.theme.active_bg_color : screen.theme.input_bg_color)
+      end
+
+      # Rebuilds the dropdown's rows, highlight and geometry, opening it if
+      # needed; closes it instead when there is nothing to show.
+      # @return [void]
+      def refill
+        if @items.empty?
+          close_menu
+          return
+        end
+
+        @overlay.lines = @items.map { |item| label_for(item) }
+        @overlay.cursor = List::Cursor.new(position: @items.index(value) || 0)
+        @overlay.open unless @overlay.open?
+        anchor
+      end
+
+      # @return [void]
+      def open_menu = refill
+
+      # @return [void]
+      def close_menu = (@overlay.close if @overlay.open?)
+
+      # Adopts the item on row `index` as {#value} and closes the dropdown.
+      # @param index [Integer]
+      # @return [void]
+      def commit(index)
+        item = @items[index]
+        close_menu
+        self.value = item
+      end
+
+      # @return [void]
+      def anchor = @overlay.anchor_to(rect, rows: @items.size, width: menu_width)
+
+      # The dropdown's width: the widest label plus {List}'s two row gutters, plus
+      # the scrollbar column when the rows can't all be shown at once — but never
+      # narrower than the Select itself, so both edges line up with the face and
+      # the panel reads as belonging to it. Only a label that needs more pushes it
+      # wider.
+      #
+      # A dropdown the screen clamps shorter than
+      # {ListDropdown::MAX_VISIBLE_ROWS} scrolls without having bought that
+      # column, ellipsizing its labels one early — the {ComboBox} trade, in the
+      # one case measuring can't predict the height.
+      # @return [Integer]
+      def menu_width
+        widest = @items.map { |item| label_for(item).display_width }.max || 0
+        measured = widest + 2 + (@items.size > ListDropdown::MAX_VISIBLE_ROWS ? 1 : 0)
+        [measured, rect.width].max
+      end
+
+      # @param item [Object]
+      # @return [StyledString] `item`'s label, or empty for `nil` — so {#value}
+      #   being unset never reaches an {#item_label} that assumes an item.
+      def label_for(item)
+        return StyledString::EMPTY if item.nil?
+
+        label = @item_label.call(item)
+        label.is_a?(StyledString) ? label : StyledString.parse(label.to_s)
+      end
+    end
+  end
+end

data/lib/tuile/styled_string.rb

@@ -542,11 +542,20 @@ module Tuile
     # wrapped continuations, hard `"\n"` breaks preserved as separate output
     # lines.
     #
+    # An indent is content, so it survives onto the first row — but there is no
+    # hanging indent:
+    #
+    #   StyledString.plain("  read config").wrap(20).map(&:to_s)
+    #   # => ["  read config"]        indent kept; the line never wrapped
+    #   StyledString.plain("  read config").wrap(6).map(&:to_s)
+    #   # => ["  read", "config"]     ...but a continuation starts at column 0
+    #
     # Whitespace runs are space or tab; other characters are treated as word
     # content. When a single character is wider than `width` (e.g. a 2-column
     # CJK character with `width = 1`), it is still emitted on its own line at
     # its natural width. The "no line exceeds `width`" guarantee therefore
-    # holds whenever every character is at most `width` columns wide.
+    # holds whenever every character is at most `width` columns wide. An indent
+    # that alone exceeds `width` is dropped rather than given a row of its own.
     #
     # @param width [Integer, nil] target column width. `nil` or `<= 0` skips
     #   wrapping and returns each hard-line as-is, so callers can pass a
@@ -720,8 +729,9 @@ module Tuile
 
       tokenize_for_wrap(hard_line).each do |type, glyphs, w|
         if type == :space
-          if line_w.zero?
-            # leading whitespace on a wrapped continuation: drop
+          if line_w.zero? && (!result.empty? || w > width)
+            # Nothing to emit: a continuation's leading run was consumed by the
+            # break, and an indent wider than the viewport conveys no nesting.
           elsif line_w + w <= width
             line_glyphs.concat(glyphs)
             line_w += w

data/lib/tuile/version.rb

@@ -2,5 +2,5 @@
 
 module Tuile
   # @return [String]
-  VERSION = "0.10.0"
+  VERSION = "0.11.0"
 end

data/lib/tuile.rb

@@ -32,5 +32,9 @@ module Tuile
   end
 
   loader = Zeitwerk::Loader.for_gem
+  # Keeps Tuile's one optional dependency optional: the file requires
+  # `bigdecimal` at load, so a host app calling Zeitwerk::Loader.eager_load_all
+  # would otherwise raise LoadError for a component it never names.
+  loader.do_not_eager_load("#{__dir__}/tuile/component/big_decimal_field.rb")
   loader.setup
 end