zaniah 0.6.2 → 0.6.3

data/lib/zaniah/ui/rich_text_surface.rb

@@ -0,0 +1,302 @@
+# frozen_string_literal: true
+
+module Zaniah
+  module UI
+    class RichTextSurface < Element
+      Run = Data.define(:start, :finish, :layout, :x, :style, :color, :size)
+      Line = Data.define(:start, :finish, :x, :y, :width, :height, :ascent, :runs, :paragraph, :first_in_paragraph)
+
+      def initialize(owner)
+        super()
+        @owner = owner
+        @layout_cache = {}
+        return unless owner.instance_variable_get(:@selectable) || owner.editable?
+
+        if owner.instance_variable_get(:@selectable)
+          on_mouse_down { |event, _cx| begin_selection(event) }
+          on_drag { |event, _cx| extend_selection(event) }
+        end
+        focusable(context: owner.editable? ? {in_text_field: true} : {in_text: true}) do |action|
+          owner.editable? ? owner.text_action(action) : action == :select_all && select_all
+        end
+        @focus_handle.on_input = ->(event) { owner.input(event) }
+      end
+
+      def request_layout(cx)
+        @cx = cx
+        @display_text = @owner.display_text
+        @visual_spans = display_spans
+        width = resolved_width(@style[:width], cx.window.content_size.width)
+        @font_size = @style[:font_size] || cx.theme.typography.size_md
+        @lines = layout_lines(width, cx)
+        @layout_node = Layout::Node.new(style: @style, measure: lambda do |available, _height|
+          target = @style[:width].is_a?(Numeric) ? width : [available, 0].max
+          @lines = layout_lines(target, cx) if target != width
+          [@lines.map { |line| line.x + line.width }.max || 0, @lines.last ? @lines.last.y + @lines.last.height : line_height]
+        end)
+      end
+
+      def prepaint(bounds, state, cx)
+        @bounds = bounds
+        super
+      end
+
+      def paint(bounds, state, prepaint, cx)
+        super
+        selection = @owner.selection.range
+        paint_selection(bounds, selection, cx) if @owner.instance_variable_get(:@selectable) && !selection.begin.eql?(selection.end)
+        @lines.each do |line|
+          line.runs.each do |run|
+            next unless run.layout && cx.text_system
+            cx.text_system.paint_line(cx.scene, run.layout, x: bounds.x + line.x + run.x,
+              y: bounds.y + line.y + line.ascent, color: run.color)
+            if run.style[:link]
+              cx.scene.underline(bounds.x + line.x + run.x, bounds.y + line.y + line.ascent + run.size,
+                [run.layout.width, 1].max, color: run.color)
+            end
+          end
+          paint_list_marker(bounds, line, cx)
+        end
+        paint_composition(bounds, cx) if @owner.buffer.composition
+        paint_caret(bounds, cx) if @owner.editable? && @owner.selection.collapsed? && cx.dispatcher.focused == @focus_handle
+        cx.window.text_runs.concat(@lines.flat_map do |line|
+          line.runs.map { |run| [bounds.x + line.x + run.x, bounds.y + line.y, @display_text.byteslice(run.start...run.finish), run.color] }
+        end) if cx.window.respond_to?(:text_runs)
+      end
+
+      def hit_test(point)
+        line = @lines.find { |item| point.y < item.y + item.height } || @lines.last
+        return 0 unless line
+        run = line.runs.find { |item| point.x < line.x + item.x + item.layout&.width.to_f } || line.runs.last
+        return line.start unless run
+        run.start + (run.layout ? run.layout.index_for_x(point.x - line.x - run.x) : 0).clamp(0, run.finish - run.start)
+      end
+
+      private
+
+      def resolved_width(value, available)
+        value = value.resolve(available) if value.is_a?(Length)
+        value.is_a?(Numeric) ? [value, 0].max : available
+      end
+
+      def display_spans
+        spans = @owner.spans.map { |span| [span.start, span.finish, span.style] }
+        composition = @owner.buffer.composition
+        return spans unless composition
+        range = @owner.selection.range
+        at, delta = range.begin, composition.text.bytesize - range.size
+        style = @owner.style_at(at)
+        spans = spans.flat_map do |first, finish, value|
+          if finish <= range.begin
+            [[first, finish, value]]
+          elsif first >= range.end
+            [[first + delta, finish + delta, value]]
+          else
+            pieces = []
+            pieces << [first, range.begin, value] if first < range.begin
+            pieces << [range.begin + composition.text.bytesize, finish + delta, value] if finish > range.end
+            pieces
+          end
+        end
+        spans << [at, at + composition.text.bytesize, style] unless style.empty?
+        spans.sort_by(&:first)
+      end
+
+      # ponytail: each candidate prefix is shaped during line breaking; long unbroken paragraphs are quadratic. Cache wins for repeated fragments; add a streaming breaker if profiling proves this hot.
+      def layout_lines(width, cx)
+        breaker = TextSystem::LineBreaker.new(@display_text, wrap: :word, kinsoku: :push)
+        ranges = breaker.ranges_with_offsets(width) do |_candidate, first, finish|
+          fragments(first, finish).sum { |from, to, style| fragment_layout(from, to, style, cx).width }
+        end
+        y = 0.0
+        ranges.each_with_index.map do |range, index|
+          paragraph_index = @display_text.byteslice(0...range.begin).count("\n")
+          para = @owner.paragraph_style_at([range.begin, @owner.text.bytesize].min)
+          indent = Integer(para[:level] || 0) * 16 + (para[:list] && para[:list] != :none ? 20 : 0)
+          parts = fragments(range.begin, range.end).map do |first, finish, style|
+            Run.new(first, finish, fragment_layout(first, finish, style, cx), 0, style,
+              style[:color] || cx.theme.colors.text, style[:size] || @font_size)
+          end
+          width_used = parts.sum { |part| part.layout.width }
+          available = [width - indent, 0].max
+          next_range = ranges[index + 1]
+          next_paragraph = next_range && @display_text.byteslice(0...next_range.begin).count("\n")
+          if para[:align] == :justify && next_range && next_paragraph == paragraph_index
+            parts = justified_parts(parts, range, available, width_used)
+            width_used = available
+          end
+          align = para[:align] || :start
+          offset = case align
+          when :center then indent + [(available - width_used) / 2.0, 0].max
+          when :end then indent + [available - width_used, 0].max
+          else indent
+          end
+          x = 0.0
+          runs = parts.map do |part|
+            Run.new(part.start, part.finish, part.layout, x, part.style, part.color, part.size).tap { x += part.layout.width }
+          end
+          ascent = runs.map { |run| run.layout&.ascent || run.size * 0.8 }.max || @font_size * 0.8
+          descent = runs.map { |run| run.layout&.descent || run.size * 0.2 }.max || @font_size * 0.2
+          height = [line_height, ascent + descent].max
+          previous_break = @display_text.byteslice(0...range.begin).rindex("\n")
+          item = Line.new(range.begin, range.end, offset, y, width_used, height, ascent, runs, paragraph_index,
+            range.begin == (previous_break ? previous_break + 1 : 0))
+          y += height
+          item
+        end
+      end
+
+      def justified_parts(parts, range, available, line_width)
+        return parts if available <= line_width
+        spaces = []
+        @display_text.byteslice(range).to_enum(:scan, /\s+/).each { spaces << Regexp.last_match.end(0) }
+        return parts if spaces.empty?
+        extra = (available - line_width) / spaces.length
+        parts.map do |part|
+          layout = part.layout
+          shift = ->(byte) { spaces.count { |finish| finish <= byte } * extra }
+          carets = layout.carets.map { |byte, x| [byte, x + shift.call(part.start + byte - range.begin)] }.freeze
+          glyphs = layout.glyphs.map do |glyph|
+            TextSystem::Glyph.new(glyph.font, glyph.id, glyph.start, glyph.finish,
+              glyph.x + shift.call(part.start + glyph.start - range.begin), glyph.advance)
+          end.freeze
+          adjusted = TextSystem::LineLayout.new(layout.text, glyphs, layout.width + shift.call(part.finish - range.begin),
+            layout.ascent, layout.descent, layout.size, carets)
+          Run.new(part.start, part.finish, adjusted, part.x, part.style, part.color, part.size)
+        end
+      end
+
+      def fragments(first, finish)
+        return [] if first == finish
+        boundaries = [first, finish]
+        @visual_spans.each do |from, to, _style|
+          boundaries << from if from > first && from < finish
+          boundaries << to if to > first && to < finish
+        end
+        boundaries.uniq.sort.each_cons(2).map { |from, to| [from, to, style_at_display(from)] }
+      end
+
+      def style_at_display(offset)
+        span = @visual_spans.find { |first, finish, _| offset >= first && offset < finish }
+        span ? span[2] : {}
+      end
+
+      def fragment_layout(first, finish, style, cx)
+        text = @display_text.byteslice(first...finish)
+        size = style[:size] || @font_size
+        font = font_for(style, cx)
+        key = [text, size, font&.object_id]
+        @layout_cache[key] ||= cx.text_system&.layout_line(text, font: font, size: size) || approximate_layout(text, size)
+      end
+
+      def approximate_layout(text, size)
+        byte = 0
+        x = 0.0
+        carets = [[0, 0.0]]
+        text.grapheme_clusters.each do |cluster|
+          byte += cluster.bytesize
+          x += Unicode.width(cluster) * size * 0.6
+          carets << [byte, x]
+        end
+        TextSystem::LineLayout.new(text, [].freeze, x, size * 0.8, size * 0.2, size, carets)
+      end
+
+      def font_for(style, cx)
+        return style[:font] if style[:font]
+        return unless cx.text_system
+        font = cx.text_system.respond_to?(:font) ? cx.text_system.font : nil
+        return font unless style[:bold] || style[:italic]
+        database = cx.text_system.respond_to?(:font_db) ? cx.text_system.font_db : nil
+        database&.find(family: font&.family, weight: style[:bold] ? 700 : 400,
+          style: style[:italic] ? :italic : :normal) || font
+      rescue StandardError
+        font
+      end
+
+      def line_height = @font_size * 1.4
+
+      def paint_selection(bounds, range, cx)
+        @lines.each do |line|
+          first, finish = [range.begin, line.start].max, [range.end, line.finish].min
+          next if finish <= first
+          line.runs.each do |run|
+            from, to = [first, run.start].max, [finish, run.finish].min
+            next if to <= from || !run.layout
+            left = run.layout.x_for_index(from - run.start)
+            right = run.layout.x_for_index(to - run.start)
+            cx.scene.quad(bounds.x + line.x + run.x + left, bounds.y + line.y,
+              [right - left, 1].max, line.height, color: cx.theme.colors.selection)
+          end
+        end
+      end
+
+      def paint_list_marker(bounds, line, cx)
+        return unless line.first_in_paragraph
+        para = @owner.paragraph_style_at([line.start, @owner.text.bytesize].min)
+        marker = case para[:list]
+        when :bullet then "•"
+        when :ordered then "#{line.paragraph + 1}."
+        else return
+        end
+        layout = cx.text_system&.layout_line(marker, size: @font_size)
+        cx.text_system&.paint_line(cx.scene, layout, x: bounds.x + line.x - 18,
+          y: bounds.y + line.y + line.ascent, color: cx.theme.colors.text)
+      end
+
+      def paint_caret(bounds, cx)
+        offset = @owner.selection.range.begin + (@owner.buffer.composition&.selection&.first || 0)
+        line = @lines.find { |item| offset.between?(item.start, item.finish) } || @lines.last
+        return unless line
+        run = line.runs.find { |item| offset.between?(item.start, item.finish) } || line.runs.last
+        x = line.x + (run ? run.x + (run.layout ? run.layout.x_for_index((offset - run.start).clamp(0, run.finish - run.start)) : 0) : 0)
+        ascent, descent = run&.layout ? [run.layout.ascent, run.layout.descent] : [@font_size * 0.8, @font_size * 0.2]
+        y, height = line.y + line.ascent - ascent, ascent + descent
+        color = run&.color || cx.theme.colors.text
+        cx.scene.layer(Scene::LAYER_FOCUS_RING) { cx.scene.quad(bounds.x + x, bounds.y + y, 1, height, color: color) }
+        cx.window.ime_state = Bounds.new(bounds.x + x, bounds.y + y, 1, height)
+      end
+
+      def paint_composition(bounds, cx)
+        offset = @owner.selection.range.begin
+        finish = offset + @owner.buffer.composition.text.bytesize
+        first, last = point_for(offset), point_for(finish)
+        cx.scene.layer(Scene::LAYER_FOCUS_RING) do
+          cx.scene.underline(bounds.x + first.x, bounds.y + first.y + @font_size * 1.25,
+            [last.x - first.x, 1].max, color: cx.theme.colors.text)
+        end
+      end
+
+      def point_for(offset)
+        line = @lines.find { |item| offset.between?(item.start, item.finish) } || @lines.last
+        return Point.new(0, 0) unless line
+        run = line.runs.find { |item| offset.between?(item.start, item.finish) } || line.runs.last
+        x = line.x + (run ? run.x + run.layout.x_for_index((offset - run.start).clamp(0, run.finish - run.start)) : 0)
+        Point.new(x, line.y)
+      end
+
+      def begin_selection(event)
+        offset = hit_test(Point.new(event.position.x - @bounds.x, event.position.y - @bounds.y))
+        @owner.selection = event.click_count == 2 ? word_selection(offset) : TextSelection.new(offset)
+        @owner.instance_variable_get(:@cx)&.window&.request_frame
+      end
+
+      def extend_selection(event)
+        return unless @owner.selection
+        offset = hit_test(Point.new(event.position.x - @bounds.x, event.position.y - @bounds.y))
+        @owner.selection = TextSelection.new(@owner.selection.anchor, offset)
+        @owner.instance_variable_get(:@cx)&.window&.request_frame
+      end
+
+      def word_selection(offset)
+        range = Unicode.word_range_at(@owner.text, [offset, @owner.text.bytesize].min)
+        TextSelection.new(range.begin, range.end)
+      end
+
+      def select_all
+        @owner.selection = TextSelection.new(0, @owner.text.bytesize)
+        @owner.instance_variable_get(:@cx)&.window&.request_frame
+        true
+      end
+    end
+  end
+end

data/lib/zaniah/ui/terminal_view.rb

@@ -35,6 +35,7 @@ module Zaniah
       end
 
       def select(range)
+        # The range addresses cells in row-major order.
         @selection = range && Range === range ? range : nil
         self
       end
@@ -74,13 +75,34 @@ module Zaniah
             cx.scene.quad(bounds.x + column * @cell_width, bounds.y + row * @cell_height,
               (run - column) * @cell_width, @cell_height, color: color(cell.background))
           end
+          if @selection&.cover?(row * @grid.columns + column)
+            cx.scene.quad(bounds.x + column * @cell_width, bounds.y + row * @cell_height,
+              @cell_width, @cell_height, color: "#ffffff33")
+          end
           if cell.width != 0 && cell.text != " "
             paint_text(cell.text, cell.foreground || @foreground, bounds, row, column, cx)
           end
+          paint_attributes(cell, bounds, row, column, cx)
           column += 1
         end
       end
 
+      def paint_attributes(cell, bounds, row, column, cx)
+        attributes = cell.attributes || {}
+        return unless cx.scene.respond_to?(:underline)
+
+        x = bounds.x + column * @cell_width
+        y = bounds.y + row * @cell_height
+        if attributes[:underline]
+          thickness = attributes[:underline] == 2 ? 2 : 1
+          cx.scene.underline(x, y + @cell_height - 2, @cell_width, color: color(cell.foreground || @foreground), thickness: thickness)
+        end
+        if attributes[:strikethrough]
+          cx.scene.underline(x, y + @cell_height * 0.52, @cell_width,
+            color: color(cell.foreground || @foreground))
+        end
+      end
+
       def paint_text(text, tint, bounds, row, column, cx)
         return unless cx.text_system
         line = cx.text_system.layout_line(text, size: @cell_height * 0.78)

data/lib/zaniah/ui.rb

@@ -13,9 +13,11 @@ require_relative "ui/structure"
 require_relative "ui/modal"
 require_relative "ui/layout_components"
 require_relative "ui/pane_grid"
+require_relative "ui/grid"
 require_relative "ui/data"
 require_relative "ui/tree_view"
 require_relative "ui/charts"
 require_relative "ui/forms"
 require_relative "ui/editors"
+require_relative "ui/rich_text_surface"
 require_relative "ui/terminal_view"

data/lib/zaniah/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Zaniah
-  VERSION = "0.6.2"
+  VERSION = "0.6.3"
 end

data/lib/zaniah.rb

@@ -25,6 +25,7 @@ require_relative "zaniah/text_selection"
 require_relative "zaniah/text_buffer"
 require_relative "zaniah/scene"
 require_relative "zaniah/png"
+require_relative "zaniah/jpeg"
 require_relative "zaniah/gif"
 require_relative "zaniah/gpu"
 require_relative "zaniah/layout"

data/sig/elements.rbs

@@ -125,6 +125,8 @@ module Zaniah
   end
   class Image < Element
     def initialize: (String path) -> void
+    def self.from_bytes: (String bytes, ?format: :auto | :png | :jpeg | :jpg | :gif) -> Image
+    attr_reader frames: Array[GIF::Frame]?
   end
   class Canvas < Element
     def initialize: () { (Bounds, FrameContext) -> void } -> void

data/sig/native.rbs

@@ -19,6 +19,7 @@ module Zaniah
         def cursor_style=: (cursor style) -> void
         def open_url: (String url) -> void
         def toggle_fullscreen: () -> void
+        def move_to_display: (Display display) -> bool
       end
     end
     module Linux
@@ -37,6 +38,7 @@ module Zaniah
         def cursor_style=: (cursor style) -> void
         def open_url: (String url) -> bool
         def toggle_fullscreen: () -> void
+        def move_to_display: (Display display) -> bool
       end
       class WaylandWindow < Headless::Window
         def initialize: (?gpu: :opengl | :gl, ?width: Numeric, ?height: Numeric, ?title: String, ?scale_factor: Numeric) -> void
@@ -53,6 +55,10 @@ module Zaniah
         def cursor_style=: (cursor style) -> void
         def open_url: (String url) -> bool
         def toggle_fullscreen: () -> void
+        # Wayland does not support arbitrary client window placement.
+        def move_to_display: (Display display) -> bool
+        # Best-effort output preference; the compositor decides whether to honor it.
+        def fullscreen_on: (Display display) -> bool
       end
     end
     module Windows
@@ -72,6 +78,7 @@ module Zaniah
         def cursor_style=: (cursor style) -> void
         def open_url: (String url) -> void
         def toggle_fullscreen: () -> void
+        def move_to_display: (Display display) -> bool
       end
       class Terminal
         attr_reader pid: Integer

data/sig/platform.rbs

@@ -85,6 +85,8 @@ module Zaniah
         def set_cursor: (cursor style) -> cursor
         def cursor_style=: (cursor style) -> cursor
         def displays: () -> Array[Display]
+        # Raises Error for backends without native physical-display placement.
+        def move_to_display: (Display display) -> bool
         def popup: () -> Popup?
         def resize: (Numeric width, Numeric height) -> void
         def input: (Input::event event) -> void

data/sig/ui.rbs

@@ -290,6 +290,36 @@ module Zaniah
       def accessibility_action: (Accessibility::Node node, Symbol action) -> bool?
       def accessibility_value: (Accessibility::Node node, Numeric value) -> bool?
     end
+    class Grid < Component
+      class Area < Data
+        attr_reader rows: Range[Integer]
+        attr_reader columns: Range[Integer]
+        def self.new: (Range[Integer] rows, Range[Integer] columns) -> Area
+                    | (rows: Range[Integer], columns: Range[Integer]) -> Area
+      end
+      attr_reader selection: Array[Area]
+      attr_reader scroll_state: ScrollState
+      attr_reader visible_rows: Range[Integer]?
+      attr_reader visible_columns: Range[Integer]?
+      def initialize: (rows: Integer, columns: Integer, ?row_height: Numeric | Proc, ?column_width: Numeric | Proc, ?frozen_rows: Integer, ?frozen_columns: Integer, ?estimated_row_height: Numeric, ?estimated_column_width: Numeric, ?overscan: Integer) { (Integer, Integer, Bounds, FrameContext) -> _Renderable? } -> void
+      def selection=: (Array[Area] areas) -> Array[Area]
+      def on_select: () { (Array[Area], Input::MouseDown?, FrameContext?) -> void } -> self
+      def on_edit: () { (Integer, Integer, Input::MouseDown?, FrameContext?) -> void } -> self
+      def on_fill: () { (Area, Area, FrameContext?) -> void } -> self
+      def on_resize: () { (Symbol, Integer, Numeric, FrameContext?) -> void } -> self
+      def set_row_height: (Integer index, Numeric height) -> self
+      def set_column_width: (Integer index, Numeric width) -> self
+      def hide_row: (Integer index) -> self
+      def unhide_row: (Integer index) -> self
+      def hide_column: (Integer index) -> self
+      def unhide_column: (Integer index) -> self
+      def hide_rows: (Array[Integer] indices, hidden: bool) -> self
+      def hide_columns: (Array[Integer] indices, hidden: bool) -> self
+      def row_hidden?: (Integer index) -> bool
+      def column_hidden?: (Integer index) -> bool
+      def freeze_panes: (rows: Integer, columns: Integer) -> self
+      def scroll_to: (row: Integer, column: Integer, ?align: :start | :center | :end | :nearest) -> self
+    end
     class Resizable < Component
       attr_reader width: Float
       attr_reader height: Float
@@ -378,6 +408,22 @@ module Zaniah
     end
     class BarChart < LineChart
     end
+    class StackedBarChart < BarChart
+    end
+    class PieChart < Sparkline
+      attr_reader slices: Array[[String, Float]]
+      def initialize: (Hash[untyped, Numeric] | Array[Numeric] data, ?width: Numeric, ?height: Numeric, ?colors: Array[color]?, ?label: String) -> void
+    end
+    class DonutChart < PieChart
+      def initialize: (Hash[untyped, Numeric] | Array[Numeric] data, ?width: Numeric, ?height: Numeric, ?colors: Array[color]?, ?label: String) -> void
+    end
+    class ScatterChart < Sparkline
+      attr_reader points: Hash[String, Array[[Float, Float]]]
+      def initialize: (Hash[untyped, Array[[Numeric, Numeric]]] | Array[[Numeric, Numeric]] series, ?width: Numeric, ?height: Numeric, ?colors: Array[color]?, ?label: String) -> void
+    end
+    class AreaChart < LineChart
+      def initialize: (Hash[untyped, Array[Numeric]] | Array[Numeric] series, ?width: Numeric, ?height: Numeric, ?colors: Array[color]?, ?stacked: bool, ?label: String) -> void
+    end
     class CodeEditor < Component
       attr_reader buffer: TextBuffer
       def initialize: (?String | TextBuffer value, ?language: Symbol?, ?line_numbers: bool, ?read_only: bool) -> void
@@ -385,8 +431,27 @@ module Zaniah
       def on_change: () { (String, FrameContext?) -> void } -> self
     end
     class RichText < Component
-      attr_reader runs: Array[Hash[Symbol, untyped]]
-      def initialize: (Array[untyped] runs, ?selectable: bool) -> void
+      class Span < Data
+        attr_reader start: Integer
+        attr_reader finish: Integer
+        attr_reader style: Hash[Symbol, untyped]
+      end
+      attr_reader buffer: TextBuffer
+      attr_reader selection: TextSelection
+      attr_reader paragraph_styles: Array[Hash[Symbol, untyped]]
+      def initialize: (String | Array[untyped] runs, ?selectable: bool, ?editable: bool) -> void
+      def text: () -> String
+      def runs: () -> Array[Hash[Symbol, untyped]]
+      def spans: () -> Array[Span]
+      def editable?: () -> bool
+      def selection=: (TextSelection value) -> TextSelection
+      def on_change: () { (String, RichText) -> void } -> self
+      def on_select: () { (TextSelection, RichText) -> void } -> self
+      def apply: (Range[Integer] range, Hash[Symbol, untyped] style) -> self
+      def insert: (Integer offset, String value, ?style: Hash[Symbol, untyped]?) -> self
+      def delete: (Range[Integer] range) -> self
+      def replace: (Range[Integer] range, String value, ?style: Hash[Symbol, untyped]?) -> self
+      def paragraph_style: (Range[Integer] range, ?align: :start | :center | :end | :justify?, ?list: :none | :bullet | :ordered?, ?level: Integer?) -> self
     end
 
     class Validation

data/sig/zaniah.rbs

@@ -172,4 +172,18 @@ module Zaniah
     def self.decode: (String bytes, ?max_pixels: Integer) -> [Integer, Integer, String]
     def self.write: (String path, Integer width, Integer height, String rgba) -> Integer
   end
+  module JPEG
+    class Error < ArgumentError
+    end
+    def self.decode: (String bytes, ?max_pixels: Integer) -> [Integer, Integer, String]
+  end
+
+  module GIF
+    class Frame < Data
+      attr_reader pixels: String
+      attr_reader delay: Numeric
+      attr_reader disposal: Integer
+    end
+    def self.decode: (String bytes, ?max_pixels: Integer) -> [Integer, Integer, Array[Frame]]
+  end
 end

metadata

@@ -1,29 +1,35 @@
 --- !ruby/object:Gem::Specification
 name: zaniah
 version: !ruby/object:Gem::Version
-  version: 0.6.2
+  version: 0.6.3
 platform: ruby
 authors:
 - Yudai Takada
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-09-21 00:00:00.000000000 Z
+date: 2026-09-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: alhena
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: 0.2.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 0.4.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: 0.2.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 0.4.0
 - !ruby/object:Gem::Dependency
   name: rexml
   requirement: !ruby/object:Gem::Requirement
@@ -84,6 +90,7 @@ files:
 - docs/adr/009-grid-scope.md
 - docs/adr/010-text-overlay-layout.md
 - docs/adr/011-stable-accessibility-identity.md
+- docs/adr/012-productivity-components.md
 - docs/adr/README.md
 - docs/animation.md
 - docs/components.md
@@ -149,6 +156,7 @@ files:
 - docs/gallery/tooltip-top-dark.png
 - docs/gallery/tooltip-top-high_contrast.png
 - docs/gallery/tooltip-top-light.png
+- docs/images.md
 - docs/index.html
 - docs/layout.md
 - docs/media/overview.apng
@@ -255,6 +263,7 @@ files:
 - lib/zaniah/input/scroll_wheel.rb
 - lib/zaniah/input/text_input.rb
 - lib/zaniah/interactivity.rb
+- lib/zaniah/jpeg.rb
 - lib/zaniah/layout.rb
 - lib/zaniah/layout/available_space.rb
 - lib/zaniah/layout/engine.rb
@@ -347,12 +356,14 @@ files:
 - lib/zaniah/ui/data.rb
 - lib/zaniah/ui/editors.rb
 - lib/zaniah/ui/forms.rb
+- lib/zaniah/ui/grid.rb
 - lib/zaniah/ui/layout_components.rb
 - lib/zaniah/ui/modal.rb
 - lib/zaniah/ui/overlays.rb
 - lib/zaniah/ui/pane_grid.rb
 - lib/zaniah/ui/pickers.rb
 - lib/zaniah/ui/primitives.rb
+- lib/zaniah/ui/rich_text_surface.rb
 - lib/zaniah/ui/scrollbar.rb
 - lib/zaniah/ui/structure.rb
 - lib/zaniah/ui/terminal_view.rb