zaniah 0.6.2 → 0.6.3

data/lib/zaniah/ui/charts.rb

@@ -161,5 +161,304 @@ module Zaniah
         end
       end
     end
+
+    class PieChart < Sparkline
+      attr_reader :slices
+
+      def initialize(data, width: 320, height: 240, colors: nil, label: "Pie chart")
+        super([1], width: width, height: height, label: label)
+        entries = data.is_a?(Hash) ? data.to_a : data.to_a.each_with_index.map { |value, index| ["#{index + 1}", value] }
+        raise ArgumentError, "pie chart needs at least one slice" if entries.empty?
+
+        @slices = entries.map do |name, value|
+          value = Float(value)
+          raise ArgumentError, "pie values must be finite and nonnegative" unless value.finite? && value >= 0
+          [name.to_s.freeze, value].freeze
+        end.freeze
+        raise ArgumentError, "pie slice labels must be unique" unless @slices.map(&:first).uniq.length == @slices.length
+        @values = @slices.map(&:last).freeze
+        @total = @values.sum
+        raise ArgumentError, "pie chart needs a positive total" unless @total.positive?
+        @series = {label.to_s => @values}.freeze
+        @width, @height, @colors, @label = Float(width), Float(height), colors, label.to_s
+        raise ArgumentError, "chart dimensions must be positive" unless @width.positive? && @height.positive?
+      end
+
+      def build(cx)
+        palette = Array(@colors || [cx.theme.colors.accent, cx.theme.colors.info, cx.theme.colors.success, cx.theme.colors.warning])
+        raise ArgumentError, "chart colors must not be empty" if palette.empty?
+
+        @canvas = Canvas.new do |bounds, context|
+          @plot_bounds = bounds
+          paint_slices(context.scene, bounds, palette)
+        end.w(@width).h(@height).on_hover { |event, context| show_slice_tooltip(event, context) }
+          .focusable(context: {in_chart: true}) { |action| chart_action(action, cx) }
+        legend = Div.new.flex_row.gap(10).children(@slices.each_with_index.map do |(name, value), index|
+          percent = value / @total * 100
+          Div.new.flex_row.items_center.gap(4)
+            .child(Div.new.w(8).h(8).bg(palette[index % palette.length]))
+            .child(Label.new("#{name}: #{format("%.1f", percent)}%", size: :xs))
+        end)
+        Div.new.gap(4).child(@canvas).child(legend)
+      end
+
+      def tui_cells(*) = spark(@values)
+
+      def accessibility_node(_cx)
+        categories = @slices.map { |name, value| {label: name, value: value}.freeze }.freeze
+        node(:image, label: @label, value: {total: @total, categories: categories, selected: selected_summary}.freeze)
+      end
+
+      protected
+
+      def tooltip_at(index)
+        name, value = @slices.fetch(index)
+        "#{name}: #{value}"
+      end
+
+      private
+
+      def paint_slices(scene, bounds, palette)
+        cx, cy = bounds.x + bounds.width / 2, bounds.y + bounds.height / 2
+        radius = [bounds.width, bounds.height].min / 2
+        angle = -Math::PI / 2
+        @slices.each_with_index do |(_name, value), index|
+          next if value.zero?
+
+          finish = angle + Math::PI * 2 * value / @total
+          scene.path(slice_path(cx, cy, radius, angle, finish), fill: palette[index % palette.length])
+          angle = finish
+        end
+      end
+
+      def slice_path(cx, cy, radius, start, finish)
+        if finish - start >= Math::PI * 2 - 1e-10
+          "M#{cx},#{cy - radius} A#{radius},#{radius} 0 1 1 #{cx},#{cy + radius} A#{radius},#{radius} 0 1 1 #{cx},#{cy - radius} Z"
+        else
+          sx, sy = polar(cx, cy, radius, start)
+          ex, ey = polar(cx, cy, radius, finish)
+          large = finish - start > Math::PI ? 1 : 0
+          "M#{cx},#{cy} L#{sx},#{sy} A#{radius},#{radius} 0 #{large} 1 #{ex},#{ey} Z"
+        end
+      end
+
+      def polar(cx, cy, radius, angle) = [cx + Math.cos(angle) * radius, cy + Math.sin(angle) * radius]
+
+      def show_slice_tooltip(event, cx)
+        return unless @plot_bounds
+
+        center_x = @plot_bounds.x + @plot_bounds.width / 2
+        center_y = @plot_bounds.y + @plot_bounds.height / 2
+        angle = (Math.atan2(event.position.y - center_y, event.position.x - center_x) + Math::PI / 2) % (Math::PI * 2)
+        target = angle / (Math::PI * 2) * @total
+        index = @values.each_index.find do |candidate|
+          target -= @values[candidate]
+          target < 0
+        end || @values.rindex(&:positive?)
+        @selected_index = index
+        cx.window.offer_tooltip(tooltip_at(index), position: event.position, delay: 0)
+      end
+    end
+
+    class DonutChart < PieChart
+      def initialize(data, **options)
+        super
+        @inner_radius = 0.56
+      end
+
+      private
+
+      def slice_path(cx, cy, radius, start, finish)
+        inner = radius * @inner_radius
+        if finish - start >= Math::PI * 2 - 1e-10
+          "M#{cx},#{cy - radius} A#{radius},#{radius} 0 1 1 #{cx},#{cy + radius} A#{radius},#{radius} 0 1 1 #{cx},#{cy - radius} " \
+            "L#{cx},#{cy - inner} A#{inner},#{inner} 0 1 0 #{cx},#{cy + inner} A#{inner},#{inner} 0 1 0 #{cx},#{cy - inner} Z"
+        else
+          sx, sy = polar(cx, cy, radius, start)
+          ex, ey = polar(cx, cy, radius, finish)
+          isx, isy = polar(cx, cy, inner, start)
+          iex, iey = polar(cx, cy, inner, finish)
+          large = finish - start > Math::PI ? 1 : 0
+          "M#{sx},#{sy} A#{radius},#{radius} 0 #{large} 1 #{ex},#{ey} L#{iex},#{iey} " \
+            "A#{inner},#{inner} 0 #{large} 0 #{isx},#{isy} Z"
+        end
+      end
+    end
+
+    class ScatterChart < Sparkline
+      attr_reader :points
+
+      def initialize(series, width: 480, height: 240, colors: nil, label: "Scatter chart")
+        input = series.is_a?(Hash) ? series : {label => series}
+        raise ArgumentError, "scatter chart needs at least one series" if input.empty?
+        @points = input.to_h do |name, values|
+          pairs = values.to_a.map do |pair|
+            raise ArgumentError, "scatter points must contain x and y" unless pair.respond_to?(:length) && pair.length == 2
+            x, y = pair.map { |value| Float(value) }
+            raise ArgumentError, "scatter values must be finite" unless x.finite? && y.finite?
+            [x, y].freeze
+          end
+          raise ArgumentError, "scatter series must not be empty" if pairs.empty?
+          [name.to_s.freeze, pairs.freeze]
+        end.freeze
+        super(@points.values.first.map(&:last), width: width, height: height, label: label)
+        @series = @points.transform_values { |pairs| pairs.map(&:last).freeze }.freeze
+        @width, @height, @colors, @label = Float(width), Float(height), colors, label.to_s
+        raise ArgumentError, "chart dimensions must be positive" unless @width.positive? && @height.positive?
+      end
+
+      def build(cx)
+        palette = Array(@colors || [cx.theme.colors.accent, cx.theme.colors.info, cx.theme.colors.success, cx.theme.colors.warning])
+        raise ArgumentError, "chart colors must not be empty" if palette.empty?
+
+        canvas = @canvas = Canvas.new do |bounds, context|
+          @plot_bounds = bounds.inset(Edges.new(12, 8, 20, 28))
+          paint_axes(context.scene, @plot_bounds, cx.theme.colors.border)
+          paint_points(context.scene, @plot_bounds, palette)
+        end.w(@width).h(@height).on_hover { |event, context| show_scatter_tooltip(event, context) }
+          .focusable(context: {in_chart: true}) { |action| chart_action(action, cx) }
+        legend = Div.new.flex_row.gap(10).children(@points.keys.each_with_index.map do |name, index|
+          Div.new.flex_row.items_center.gap(4).child(Div.new.w(8).h(8).bg(palette[index % palette.length]))
+            .child(Label.new(name, size: :xs))
+        end)
+        Div.new.gap(4).child(canvas).child(legend)
+      end
+
+      def tui_cells(*) = spark(@series.values.first)
+
+      def accessibility_node(_cx)
+        node(:image, label: @label, value: {series: @points, selected: selected_summary}.freeze)
+      end
+
+      protected
+
+      def tooltip_at(index)
+        @points.map do |name, values|
+          x, y = values[[index, values.length - 1].min]
+          "#{name}: (#{x}, #{y})"
+        end.join(" · ")
+      end
+
+      private
+
+      def paint_axes(scene, bounds, color)
+        scene.path("M#{bounds.x},#{bounds.y}V#{bounds.bottom}H#{bounds.right}", stroke: color, width: 1)
+      end
+
+      def paint_points(scene, bounds, palette)
+        all = @points.values.flatten(1)
+        min_x, max_x = all.map(&:first).minmax
+        min_y, max_y = all.map(&:last).minmax
+        @screen_points = []
+        @points.each_with_index do |(name, values), index|
+          paths = values.map do |x_value, y_value|
+            x = bounds.x + (max_x == min_x ? 0.5 : (x_value - min_x) / (max_x - min_x)) * bounds.width
+            y = bounds.bottom - (max_y == min_y ? 0.5 : (y_value - min_y) / (max_y - min_y)) * bounds.height
+            @screen_points << [name, x_value, y_value, x, y]
+            "M#{x - 3},#{y} A3,3 0 1 0 #{x + 3},#{y} A3,3 0 1 0 #{x - 3},#{y} Z"
+          end.join
+          scene.path(paths, fill: palette[index % palette.length]) unless paths.empty?
+        end
+      end
+
+      def show_scatter_tooltip(event, cx)
+        nearest = @screen_points.min_by do |(_name, _x_value, _y_value, x, y)|
+          (x - event.position.x)**2 + (y - event.position.y)**2
+        end
+        return unless nearest
+
+        name, x_value, y_value = nearest
+        cx.window.offer_tooltip("#{name}: (#{x_value}, #{y_value})", position: event.position, delay: 0)
+      end
+    end
+
+    class AreaChart < LineChart
+      def initialize(series, width: 480, height: 240, colors: nil, stacked: false, label: "Area chart")
+        super(series, width: width, height: height, colors: colors, label: label)
+        raise ArgumentError, "stacked area series must have equal lengths" if stacked && @series.values.map(&:length).uniq.length > 1
+        raise ArgumentError, "stacked area values must be nonnegative" if stacked && @series.values.flatten.any?(&:negative?)
+        @stacked = stacked
+      end
+
+      def build(cx)
+        palette = Array(@colors || [cx.theme.colors.accent, cx.theme.colors.info, cx.theme.colors.success, cx.theme.colors.warning])
+        raise ArgumentError, "chart colors must not be empty" if palette.empty?
+
+        canvas = @canvas = Canvas.new do |bounds, context|
+          @plot_bounds = bounds.inset(Edges.new(12, 8, 20, 28))
+          axes(context.scene, @plot_bounds, cx.theme.colors.border)
+          paint_areas(context.scene, @plot_bounds, palette)
+        end.w(@width).h(@height).on_hover { |event, context| show_line_tooltip(event, context) }
+          .focusable(context: {in_chart: true}) { |action| chart_action(action, cx) }
+        legend = Div.new.flex_row.gap(10).children(@series.keys.each_with_index.map do |name, index|
+          Div.new.flex_row.items_center.gap(4).child(Div.new.w(8).h(8).bg(palette[index % palette.length]))
+            .child(Label.new(name, size: :xs))
+        end)
+        Div.new.gap(4).child(canvas).child(legend)
+      end
+
+      private
+
+      def paint_areas(scene, bounds, palette)
+        count = @series.values.map(&:length).max
+        totals = Array.new(count, 0.0)
+        if @stacked
+          @series.each_value { |values| values.each_with_index { |value, index| totals[index] += value } }
+          minimum, maximum = 0.0, totals.max
+        else
+          minimum, maximum = [0.0, *@series.values.flatten].minmax
+        end
+        span = maximum == minimum ? 1.0 : maximum - minimum
+        y = ->(value) { bounds.bottom - (value - minimum) / span * bounds.height }
+        x = ->(index, length) { bounds.x + (length == 1 ? 0.5 : index.to_f / (length - 1)) * bounds.width }
+        cumulative = Array.new(count, 0.0)
+
+        @series.each_value.with_index do |values, series_index|
+          base = @stacked ? cumulative.dup : Array.new(values.length, 0.0)
+          top = values.each_with_index.map { |value, index| @stacked ? (cumulative[index] += value) : value }
+          top_x = top.each_index.map { |index| x.call(index, top.length) }
+          base_x = base.each_index.map { |index| x.call(index, base.length) }
+          path = "M#{base_x.first},#{y.call(base.first)} " \
+            "L#{top_x.zip(top).map { |px, value| "#{px},#{y.call(value)}" }.join(" L")} " \
+            "L#{base_x.zip(base).reverse.map { |px, value| "#{px},#{y.call(value)}" }.join(" L")} Z"
+          scene.path(path, fill: palette[series_index % palette.length])
+        end
+      end
+    end
+
+    class StackedBarChart < BarChart
+      private
+
+      def paint_bars(scene, bounds, palette)
+        count = @series.values.map(&:length).max
+        positive_totals = Array.new(count, 0.0)
+        negative_totals = Array.new(count, 0.0)
+        @series.each_value do |values|
+          values.each_with_index do |value, index|
+            value.negative? ? negative_totals[index] += value : positive_totals[index] += value
+          end
+        end
+        minimum, maximum = [negative_totals.min, 0].min, [positive_totals.max, 0].max
+        span = maximum == minimum ? 1.0 : maximum - minimum
+        y = ->(value) { bounds.bottom - (value - minimum) / span * bounds.height }
+        zero = y.call(0)
+        group_width = bounds.width / [count, 1].max
+        bar_width = group_width * 0.75
+        positive = Array.new(count, 0.0)
+        negative = Array.new(count, 0.0)
+
+        @series.values.each_with_index do |values, series_index|
+          values.each_with_index do |value, index|
+            base = value.negative? ? negative[index] - value : positive[index] - value
+            finish = base + value
+            first, last = [y.call(base), y.call(finish)].minmax
+            x = bounds.x + index * group_width + (group_width - bar_width) / 2
+            scene.path("M#{x},#{first}H#{x + bar_width}V#{[last, first + 1].max}H#{x}Z", fill: palette[series_index % palette.length])
+            value.negative? ? negative[index] = finish : positive[index] = finish
+          end
+        end
+        scene.path("M#{bounds.x},#{zero}H#{bounds.right}", stroke: "#777", width: 1)
+      end
+    end
   end
 end

data/lib/zaniah/ui/editors.rb

@@ -34,34 +34,324 @@ module Zaniah
     end
 
     class RichText < Component
-      attr_reader :runs
+      Span = Data.define(:start, :finish, :style)
+      STYLE_KEYS = %i[bold italic size color font link].freeze
+      LIST_STYLES = %i[none bullet ordered].freeze
 
-      def initialize(runs, selectable: true)
+      attr_reader :buffer, :selection, :paragraph_styles
+
+      def initialize(runs, selectable: true, editable: false)
         super()
-        @runs, @selectable = normalize_runs(runs), !!selectable
+        text, @spans = normalize_runs(runs)
+        @buffer = TextBuffer.new(text)
+        @paragraph_styles = Array.new(text.count("\n") + 1) { {} }
+        @selection, @selectable, @editable = TextSelection.new(0), !!selectable, !!editable
       end
 
-      def build(cx)
-        Div.new.flex_row.style(flex_wrap: :wrap).children(@runs.map do |run|
-          text = Text.new(run[:text], size: run[:size] || cx.theme.typography.size_md,
-            color: run[:color] || cx.theme.colors.text)
-          text.selectable if @selectable
-          text
+      def text = @buffer.to_s
+
+      def runs
+        slices = []
+        offset = 0
+        @spans.each do |span|
+          if offset < span.start
+            slices << {text: text.byteslice(offset...span.start)}
+          end
+          slices << {text: text.byteslice(span.start...span.finish), **span.style}
+          offset = span.finish
+        end
+        slices << {text: text.byteslice(offset..)} if offset < text.bytesize
+        slices.freeze
+      end
+
+      def spans = @spans
+      def editable? = @editable
+      def on_change(&block) = (@on_change = block; self)
+      def on_select(&block) = (@on_select = block; self)
+
+      def selection=(value)
+        raise ArgumentError, "expected a TextSelection" unless value.is_a?(TextSelection)
+        checked_offset(value.anchor)
+        checked_offset(value.head)
+        @selection = value
+        @on_select&.call(value, self)
+        @cx&.window&.request_frame
+        value
+      end
+
+      def apply(range, style)
+        first, finish = checked_range(range)
+        changes = normalize_style(style)
+        return self if first == finish || changes.empty?
+        boundaries = [0, text.bytesize, first, finish, *@spans.flat_map { |span| [span.start, span.finish] }].uniq.sort
+        @spans = merge_spans(boundaries.each_cons(2).filter_map do |from, to|
+          next if from == to
+          current = style_for_range(from)
+          updated = current.dup
+          changes.each { |key, value| value.nil? ? updated.delete(key) : updated[key] = value } if from >= first && to <= finish
+          Span.new(from, to, updated.freeze) unless updated.empty?
+        end)
+        changed
+      end
+
+      def insert(offset, value, style: nil)
+        offset = checked_offset(offset)
+        validate_text(value)
+        return self if value.empty?
+        inherited = style ? normalize_style(style) : style_at(offset)
+        size, newlines = value.bytesize, value.count("\n")
+        @buffer.insert(offset, value)
+        @spans = merge_spans(@spans.flat_map do |span|
+          if span.finish <= offset
+            [span]
+          elsif span.start >= offset
+            [Span.new(span.start + size, span.finish + size, span.style)]
+          else
+            [Span.new(span.start, offset, span.style), Span.new(offset + size, span.finish + size, span.style)]
+          end
+        end + (inherited.empty? ? [] : [Span.new(offset, offset + size, inherited.freeze)]))
+        if newlines.positive?
+          line = @buffer.line_at(offset)
+          @paragraph_styles.insert(line + 1, *Array.new(newlines) { @paragraph_styles[line].dup.freeze })
+        end
+        sync_paragraph_styles
+        @selection = TextSelection.new(offset + size)
+        changed
+      end
+
+      def delete(range)
+        first, finish = checked_range(range)
+        return self if first == finish
+        old = text
+        first_line = @buffer.line_at(first)
+        removed_lines = old.byteslice(first...finish).count("\n")
+        @buffer.delete(first...finish)
+        delta = finish - first
+        @spans = merge_spans(@spans.filter_map do |span|
+          from = map_offset(span.start, first, finish, delta)
+          to = map_offset(span.finish, first, finish, delta)
+          Span.new(from, to, span.style) if to > from
         end)
+        @paragraph_styles.slice!(first_line + 1, removed_lines) if removed_lines.positive?
+        sync_paragraph_styles
+        @selection = TextSelection.new(first)
+        changed
+      end
+
+      def replace(range, value, style: nil)
+        first, finish = checked_range(range)
+        validate_text(value)
+        return delete(first...finish) if value.empty?
+        inherited = style ? normalize_style(style) : style_at(first)
+        first_line, last_line = @buffer.line_at(first), @buffer.line_at(finish)
+        before_styles = @paragraph_styles.take(first_line)
+        paragraph_style = @paragraph_styles.fetch(first_line, {}).dup.freeze
+        after_styles = @paragraph_styles.drop(last_line + 1)
+        @buffer.replace(first...finish, value)
+        delta = finish - first
+        size = value.bytesize
+        replacement_spans = @spans.flat_map do |span|
+          if finish == first
+            if span.finish <= first
+              [span]
+            elsif span.start >= first
+              [Span.new(span.start + size, span.finish + size, span.style)]
+            else
+              [Span.new(span.start, first, span.style), Span.new(first + size, span.finish + size, span.style)]
+            end
+          elsif span.finish <= first
+            [span]
+          elsif span.start >= finish
+            [Span.new(span.start - delta + size, span.finish - delta + size, span.style)]
+          else
+            pieces = []
+            pieces << Span.new(span.start, first, span.style) if span.start < first
+            pieces << Span.new(first + size, span.finish - delta + size, span.style) if span.finish > finish
+            pieces
+          end
+        end
+        replacement_spans << Span.new(first, first + size, inherited.freeze) unless inherited.empty?
+        @spans = merge_spans(replacement_spans)
+        replacement_paragraphs = Array.new(value.count("\n") + 1) { paragraph_style }
+        @paragraph_styles = before_styles + replacement_paragraphs + after_styles
+        sync_paragraph_styles
+        @selection = TextSelection.new(first + size)
+        changed
+      end
+
+      def paragraph_style(range, align: nil, list: nil, level: nil)
+        first, finish = checked_range(range)
+        raise ArgumentError, "align must be start, center, end, or justify" if align && !%i[start center end justify].include?(align)
+        raise ArgumentError, "list must be none, bullet, or ordered" if list && !LIST_STYLES.include?(list)
+        raise ArgumentError, "level must be a nonnegative integer" if level && (!level.is_a?(Integer) || level.negative?)
+        first_line, last_line = @buffer.line_at(first), @buffer.line_at(finish)
+        last_line = [last_line, @paragraph_styles.length - 1].min
+        values = {align: align, list: list, level: level}.compact
+        (first_line..last_line).each { |index| @paragraph_styles[index] = @paragraph_styles[index].merge(values).freeze }
+        @on_change&.call(text, self)
+        @cx&.window&.request_frame
+        self
+      end
+
+      def build(cx) = (@cx = cx; RichTextSurface.new(self))
+      def tui_cells(*) = text
+      def accessibility_node(_cx) = node(@editable ? :textbox : :text, label: "Rich text", value: text,
+        states: {multiline: true, readonly: !@editable}, actions: @editable ? %i[focus set_value] : [])
+
+      def display_text
+        return text unless @buffer.composition
+        range = @selection.range
+        text.byteslice(0...range.begin) + @buffer.composition.text + text.byteslice(range.end..)
+      end
+
+      def text_action(action)
+        head = @selection.head
+        case action
+        when :select_all then self.selection = TextSelection.new(0, text.bytesize)
+        when :move_left then self.selection = TextSelection.new(@selection.collapsed? ? Unicode.previous_boundary(text, head) : @selection.range.begin)
+        when :move_right then self.selection = TextSelection.new(@selection.collapsed? ? Unicode.next_boundary(text, head) : @selection.range.end)
+        when :select_left then self.selection = TextSelection.new(@selection.anchor, Unicode.previous_boundary(text, head))
+        when :select_right then self.selection = TextSelection.new(@selection.anchor, Unicode.next_boundary(text, head))
+        when :line_start, :select_line_start then move_line_edge(action, :start)
+        when :line_end, :select_line_end then move_line_edge(action, :end)
+        when :delete_backward then delete_backward
+        when :delete_forward then delete_forward
+        when :insert_newline then replace_selection("\n") if @editable
+        else return false
+        end
+        true
+      end
+
+      def input(event)
+        case event
+        when Input::TextInput
+          return false unless @editable
+          replace_selection(event.text)
+        when Input::Composition
+          return false unless @editable
+          @buffer.set_composition(event.text, selection: event.selection)
+        else return false
+        end
+        true
+      end
+
+      def changed
+        @on_change&.call(text, self)
+        @cx&.window&.request_frame
+        self
+      end
+
+      def style_at(offset)
+        span = @spans.find { |item| offset >= item.start && offset < item.finish } ||
+          @spans.reverse.find { |item| item.finish == offset }
+        span ? span.style.dup : {}
+      end
+
+      def style_for_range(offset)
+        @spans.find { |span| offset >= span.start && offset < span.finish }&.style&.dup || {}
       end
 
-      def tui_cells(*) = @runs.map { |run| run[:text] }.join
-      def accessibility_node(_cx) = node(:text, label: tui_cells)
+      def paragraph_style_at(offset)
+        @paragraph_styles.fetch(@buffer.line_at([offset, text.bytesize].min), {})
+      end
 
       private
 
       def normalize_runs(value)
-        Array(value).map do |run|
+        text, spans = +"", []
+        Array(value).each do |run|
           run = {text: run} unless run.is_a?(Hash)
           raise ArgumentError, "rich text runs require text" unless run.key?(:text)
-          {text: run[:text].to_s.encode(Encoding::UTF_8), color: run[:color], size: run[:size]}.freeze
+          part = run[:text].to_s.encode(Encoding::UTF_8)
+          style = normalize_style(run.reject { |key, _| key.to_sym == :text })
+          first = text.bytesize
+          text << part
+          spans << Span.new(first, text.bytesize, style.freeze) unless part.empty? || style.empty?
+        end
+        [text, merge_spans(spans)]
+      end
+
+      def normalize_style(value)
+        raise ArgumentError, "rich text style must be a Hash" unless value.is_a?(Hash)
+        style = value.to_h { |key, item| [key.to_sym, item] }
+        unknown = style.keys - STYLE_KEYS
+        raise ArgumentError, "unsupported rich text style: #{unknown.join(', ')}" unless unknown.empty?
+        if style[:size] && (!style[:size].is_a?(Numeric) || !style[:size].finite? || !style[:size].positive?)
+          raise ArgumentError, "font size must be finite and positive"
+        end
+        style
+      end
+
+      def merge_spans(spans)
+        spans.sort_by(&:start).each_with_object([]) do |span, result|
+          next if span.start == span.finish
+          previous = result.last
+          if previous && previous.finish == span.start && previous.style == span.style
+            result[-1] = Span.new(previous.start, span.finish, span.style)
+          else
+            result << span
+          end
         end.freeze
       end
+
+      def checked_range(range)
+        raise ArgumentError, "expected a Range" unless range.is_a?(Range)
+        first, finish = Integer(range.begin), Integer(range.end)
+        finish += 1 unless range.exclude_end?
+        checked_offset(first)
+        checked_offset(finish)
+        raise ArgumentError, "range is reversed" if finish < first
+        [first, finish]
+      end
+
+      def checked_offset(offset)
+        raise ArgumentError, "offset is outside text" unless offset.is_a?(Integer) && offset.between?(0, text.bytesize)
+        raise ArgumentError, "offset splits a grapheme cluster" unless Unicode.grapheme_boundary?(text, offset)
+        offset
+      end
+
+      def validate_text(value)
+        raise ArgumentError, "text must be valid UTF-8" unless value.is_a?(String) && value.encoding == Encoding::UTF_8 && value.valid_encoding?
+      end
+
+      def map_offset(offset, first, finish, delta)
+        return offset if offset <= first
+        return offset - delta if offset >= finish
+        first
+      end
+
+      def sync_paragraph_styles
+        length = text.count("\n") + 1
+        @paragraph_styles = @paragraph_styles.take(length)
+        @paragraph_styles << {}.freeze while @paragraph_styles.length < length
+      end
+
+      def replace_selection(value)
+        range = @selection.range
+        if range.begin == range.end
+          insert(range.begin, value)
+        else
+          replace(range, value)
+        end
+      end
+
+      def delete_backward
+        range = @selection.collapsed? ? Unicode.previous_boundary(text, @selection.head)...@selection.head : @selection.range
+        delete(range)
+      end
+
+      def delete_forward
+        range = @selection.collapsed? ? @selection.head...Unicode.next_boundary(text, @selection.head) : @selection.range
+        delete(range)
+      end
+
+      def move_line_edge(action, edge)
+        line = @buffer.line_at(@selection.head)
+        start = @buffer.offset_at(line, 0)
+        finish = text.index("\n", start) || text.bytesize
+        target = edge == :start ? start : finish
+        self.selection = action.to_s.start_with?("select") ? TextSelection.new(@selection.anchor, target) : TextSelection.new(target)
+      end
     end
   end
 end