zaniah 0.2.0 → 0.3.0

data/lib/zaniah/input/focus_tree.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Zaniah
+  module Input
+    class FocusTree
+      def initialize
+        @roots, @traps = [], []
+      end
+
+      def register(handle)
+        root = handle
+        root = root.parent while root.parent
+        @roots << root unless @roots.include?(root)
+        self
+      end
+
+      def clear = @roots.clear
+
+      def next(from = nil) = move(from, 1)
+      def previous(from = nil) = move(from, -1)
+
+      def spatial(from, direction)
+        return unless from&.bounds
+        raise ArgumentError, "direction must be left, right, up, or down" unless %i[left right up down].include?(direction)
+        source = from.bounds
+        sx, sy = center(source)
+        candidates.reject { |handle| handle.equal?(from) || !handle.bounds }.select do |handle|
+          tx, ty = center(handle.bounds)
+          delta = %i[left right].include?(direction) ? tx - sx : ty - sy
+          %i[left up].include?(direction) ? delta.negative? : delta.positive?
+        end.min_by do |handle|
+          target = handle.bounds
+          tx, ty = center(target)
+          primary = %i[left right].include?(direction) ? tx - sx : ty - sy
+          cross_gap = %i[left right].include?(direction) ? interval_gap(source.y, source.bottom, target.y, target.bottom) : interval_gap(source.x, source.right, target.x, target.right)
+          [cross_gap.zero? ? 0 : 1, primary.abs, cross_gap, Math.hypot(tx - sx, ty - sy)]
+        end
+      end
+
+      def trap(handle)
+        @traps << handle unless @traps.last.equal?(handle)
+        return handle unless block_given?
+        begin
+          yield
+        ensure
+          restore
+        end
+      end
+
+      def restore = @traps.pop
+      def release_trap(handle) = @traps.delete(handle)
+
+      private
+
+      def move(from, step)
+        items = candidates
+        return if items.empty?
+        index = items.index(from)
+        items[index ? (index + step) % items.length : (step.positive? ? 0 : -1)]
+      end
+
+      def candidates
+        list = []
+        roots = @traps.empty? ? @roots : [@traps.last]
+        visit = ->(handle) do
+          list << handle if handle.focusable && !handle.tab_index.nil?
+          handle.children.each(&visit)
+        end
+        roots.each(&visit)
+        list.each_with_index.sort_by { |(handle, index)| [handle.tab_index, index] }.map!(&:first)
+      end
+
+      def center(bounds) = [bounds.x + bounds.width / 2.0, bounds.y + bounds.height / 2.0]
+      def interval_gap(a1, a2, b1, b2) = [a1 - b2, b1 - a2, 0].max
+    end
+  end
+end

data/lib/zaniah/input/keymap.rb

@@ -7,6 +7,83 @@ require_relative "context_predicate"
 module Zaniah
   module Input
     class Keymap
+      class << self
+        def default_ui(platform: RUBY_PLATFORM, **options)
+          platform_defaults(platform, **options)
+        end
+
+        def platform_defaults(platform, **options)
+          primary = platform.to_s.match?(/darwin|mac/) ? "cmd" : "ctrl"
+          new(**options)
+            .bind("tab", :focus_next)
+            .bind("shift-tab", :focus_previous)
+            .bind("left", :focus_left, context: "!in_text_field && !in_list")
+            .bind("right", :focus_right, context: "!in_text_field && !in_list")
+            .bind("up", :focus_up, context: "!in_text_field && !in_list")
+            .bind("down", :focus_down, context: "!in_text_field && !in_list")
+            .bind("enter", :activate)
+            .bind("space", :activate, context: "!in_text_field")
+            .bind("esc", :dismiss)
+            .bind("home", :first, context: "in_list")
+            .bind("end", :last, context: "in_list")
+            .bind("pageup", :page_up, context: "in_list")
+            .bind("pagedown", :page_down, context: "in_list")
+            .bind("up", :previous_option, context: "in_list")
+            .bind("down", :next_option, context: "in_list")
+            .bind("#{primary}-a", :select_all, context: "in_text_field || in_list")
+            .bind("left", :move_left, context: "in_text_field")
+            .bind("right", :move_right, context: "in_text_field")
+            .bind("shift-left", :select_left, context: "in_text_field")
+            .bind("shift-right", :select_right, context: "in_text_field")
+            .bind("home", :line_start, context: "in_text_field")
+            .bind("end", :line_end, context: "in_text_field")
+            .bind("shift-home", :select_line_start, context: "in_text_field")
+            .bind("shift-end", :select_line_end, context: "in_text_field")
+            .bind("backspace", :delete_backward, context: "in_text_field")
+            .bind("delete", :delete_forward, context: "in_text_field")
+            .bind("enter", :insert_newline, context: "in_text_field")
+            .bind("left", :decrement, context: "in_slider")
+            .bind("down", :decrement, context: "in_slider")
+            .bind("right", :increment, context: "in_slider")
+            .bind("up", :increment, context: "in_slider")
+            .bind("home", :minimum, context: "in_slider")
+            .bind("end", :maximum, context: "in_slider")
+            .bind("pageup", :increment_page, context: "in_slider")
+            .bind("pagedown", :decrement_page, context: "in_slider")
+            .bind("up", :previous_option, context: "in_menu || in_tabs")
+            .bind("left", :previous_option, context: "in_menu || in_tabs")
+            .bind("down", :next_option, context: "in_menu || in_tabs")
+            .bind("right", :next_option, context: "in_menu || in_tabs")
+            .bind("home", :first, context: "in_menu || in_tabs")
+            .bind("end", :last, context: "in_menu || in_tabs")
+            .bind("up", :previous_option, context: "in_tree")
+            .bind("down", :next_option, context: "in_tree")
+            .bind("home", :first, context: "in_tree")
+            .bind("end", :last, context: "in_tree")
+            .bind("left", :collapse, context: "in_tree")
+            .bind("right", :expand, context: "in_tree")
+            .bind("up", :previous_option, context: "in_table")
+            .bind("down", :next_option, context: "in_table")
+            .bind("shift-up", :extend_previous, context: "in_table")
+            .bind("shift-down", :extend_next, context: "in_table")
+            .bind("home", :first, context: "in_table")
+            .bind("end", :last, context: "in_table")
+            .bind("pageup", :page_up, context: "in_table")
+            .bind("pagedown", :page_down, context: "in_table")
+            .bind("#{primary}-a", :select_all, context: "in_table")
+            .bind("up", :previous_option, context: "in_combobox")
+            .bind("down", :next_option, context: "in_combobox")
+            .bind("home", :first, context: "in_combobox")
+            .bind("end", :last, context: "in_combobox")
+            .bind("enter", :choose_option, context: "in_combobox")
+            .bind("esc", :dismiss, context: "in_combobox")
+            .bind("left", :previous_option, context: "in_chart")
+            .bind("right", :next_option, context: "in_chart")
+            .bind("home", :first, context: "in_chart")
+            .bind("end", :last, context: "in_chart")
+        end
+      end
+
       def initialize(timeout: 1.0, clock: MONOTONIC_CLOCK)
         @bindings, @pending, @last_time, @timeout, @clock = [], [], 0, timeout, clock
       end

data/lib/zaniah/input.rb

@@ -13,5 +13,6 @@ require_relative "input/keystroke"
 require_relative "input/context_predicate"
 require_relative "input/keymap"
 require_relative "input/focus_handle"
+require_relative "input/focus_tree"
 require_relative "input/dispatcher"
 require_relative "input/action_registry"

data/lib/zaniah/interactivity.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "set"
+
+module Zaniah
+  class Interactivity
+    def initialize = @flags = {}
+
+    def resolve(dispatcher, pointer_position, pointer_down)
+      @flags.clear
+      chain = dispatcher.hover_chain(pointer_position)
+      chain.each { |owner| flags(owner) << :hover }
+      chain.each { |owner| flags(owner) << :active } if pointer_down
+      owner = dispatcher.focused&.owner
+      flags(owner) << :focus if owner
+      flags(owner) << :focus_visible if owner && dispatcher.focus_visible?
+      self
+    end
+
+    def for(owner, static = nil)
+      result = @flags[owner]&.dup || Set.new
+      result.merge(static) if static
+      result
+    end
+
+    private
+
+    def flags(owner) = @flags[owner] ||= Set.new
+  end
+end

data/lib/zaniah/layout/engine.rb

@@ -3,6 +3,14 @@
 module Zaniah
   module Layout
     class Engine
+      include GridLayout
+      EDGE_KEYS = {
+        padding: [%i[padding_top padding_right padding_bottom padding_left], :padding_start, :padding_end],
+        margin: [%i[margin_top margin_right margin_bottom margin_left], :margin_start, :margin_end],
+        border: [%i[border_top border_right border_bottom border_left], :border_start, :border_end]
+      }.freeze
+      ZERO_EDGES = [0, 0, 0, 0].freeze
+
       def initialize(rem: 16) = @rem = rem
 
       def compute(root, width:, height:, x: 0, y: 0)
@@ -15,11 +23,23 @@ module Zaniah
 
       def resolve_length(length, available, fallback = nil)
         return fallback if length.nil? || length == :auto
-        length.is_a?(Length) ? length.resolve(available || 0, rem: @rem) : Float(length)
+        return length.resolve(available || 0, rem: @rem) if length.is_a?(Length)
+        length.is_a?(Numeric) ? length : Float(length)
       end
 
       def resolve_edges(style, name, available)
-        input = style[name]
+        values = style.to_h
+        input = values[name]
+        direction = values[:direction]
+        raise ArgumentError, "direction must be ltr or rtl" unless %i[ltr rtl].include?(direction)
+        physical, start_key, end_key = EDGE_KEYS.fetch(name)
+        sides = physical.map { |key| values[key] }
+        start, finish = values[start_key], values[end_key]
+        if input.is_a?(Numeric) && sides.none? && start.nil? && finish.nil?
+          return ZERO_EDGES if input.zero?
+          return [input, input, input, input]
+        end
+
         input = input.to_h.values if input.is_a?(Edges)
         input = [input] unless input.is_a?(Array)
         input = case input.length
@@ -29,26 +49,59 @@ module Zaniah
         when 4 then input
         else raise ArgumentError, "invalid #{name}"
         end
-        %i[top right bottom left].each_with_index.map do |side, i|
-          val = style["#{name}_#{side}".to_sym] || input[i]
+        values = sides.each_with_index.map do |value, i|
+          val = value || input[i]
           val == :auto ? :auto : resolve_length(val, available, 0)
         end
+        left, right = direction == :ltr ? [start, finish] : [finish, start]
+        values[3] = left == :auto ? :auto : resolve_length(left, available, 0) unless left.nil?
+        values[1] = right == :auto ? :auto : resolve_length(right, available, 0) unless right.nil?
+        values
       end
 
       def clamp_size(node, dimension, size, available)
-        min = resolve_length(node.style["min_#{dimension}".to_sym], available, 0)
-        max = resolve_length(node.style["max_#{dimension}".to_sym], available, Float::INFINITY)
+        clamp_value(node.style.to_h, dimension, size, available)
+      end
+
+      def clamp_value(values, dimension, size, available)
+        if dimension == :width
+          min, max = values[:min_width], values[:max_width]
+        else
+          min, max = values[:min_height], values[:max_height]
+        end
+        return size.clamp(min, [min, max].max) if min.is_a?(Numeric) && max.is_a?(Numeric)
+        min = resolve_length(min, available, 0)
+        max = resolve_length(max, available, Float::INFINITY)
         size.clamp(min, [min, max].max)
       end
 
       def natural_size(node, available_w, available_h)
-        s = node.style
+        style = node.style
+        s = style.to_h
         return [0, 0] if s[:display] == :none
-        p = resolve_edges(s, :padding, available_w).map { |v| v == :auto ? 0 : v }
-        b = resolve_edges(s, :border, available_w).map { |v| v == :auto ? 0 : v }
-        padding_w, padding_h = p[1] + p[3] + b[1] + b[3], p[0] + p[2] + b[0] + b[2]
+        if !node.measure && node.children.empty? && s.length == Style::DEFAULTS.length &&
+            s[:padding] == 0 && s[:border] == 0 && !s[:aspect_ratio] &&
+            !s[:padding_start] && !s[:padding_end] && !s[:border_start] && !s[:border_end] &&
+            s[:min_width] == 0 && s[:min_height] == 0 &&
+            s[:max_width] == Float::INFINITY && s[:max_height] == Float::INFINITY
+          return [resolve_length(s[:width], available_w, 0), resolve_length(s[:height], available_h, 0)]
+        end
+        padding, border = uniform_edge(style, :padding), uniform_edge(style, :border)
+        if padding && border
+          padding_w = padding_h = (padding + border) * 2
+        else
+          p = resolve_edges(style, :padding, available_w).map { |edge| edge == :auto ? 0 : edge }
+          b = resolve_edges(style, :border, available_w).map { |edge| edge == :auto ? 0 : edge }
+          padding_w, padding_h = p[1] + p[3] + b[1] + b[3], p[0] + p[2] + b[0] + b[2]
+        end
         w = resolve_length(s[:width], available_w)
         h = resolve_length(s[:height], available_h)
+        if s[:aspect_ratio]
+          ratio = Float(s[:aspect_ratio])
+          raise ArgumentError, "aspect ratio must be positive and finite" unless ratio.positive? && ratio.finite?
+          h = w / ratio if w && !h
+          w = h * ratio if h && !w
+        end
         if node.measure
           measured = node.measure.call([available_w - padding_w, 0].max, [available_h - padding_h, 0].max)
           w ||= measured[0] + padding_w
@@ -61,10 +114,17 @@ module Zaniah
           w ||= (row ? sizes.sum(&:first) + gap : sizes.map(&:first).max || 0) + padding_w
           h ||= (row ? sizes.map(&:last).max || 0 : sizes.sum(&:last) + gap) + padding_h
         end
-        [clamp_size(node, :width, w || padding_w, available_w), clamp_size(node, :height, h || padding_h, available_h)]
+        [clamp_value(s, :width, w || padding_w, available_w), clamp_value(s, :height, h || padding_h, available_h)]
+      end
+
+      def uniform_edge(style, name)
+        values = style.to_h
+        physical, start_key, end_key = EDGE_KEYS.fetch(name)
+        value = values[name]
+        value if value.is_a?(Numeric) && physical.none? { |key| values[key] } && values[start_key].nil? && values[end_key].nil?
       end
 
-      def layout(node, x, y, width, height, available_w, available_h)
+      def layout(node, x, y, width, height, available_w, available_h, clamp = true)
         key = [node.generation, x, y, width, height, available_w, available_h]
         return if node.cache[key]
         if node.style[:display] == :none
@@ -72,12 +132,20 @@ module Zaniah
           node.children.each { |child| hide(child, x, y) }
           return
         end
-        width = clamp_size(node, :width, width, available_w)
-        height = clamp_size(node, :height, height, available_h)
+        if clamp
+          width = clamp_size(node, :width, width, available_w)
+          height = clamp_size(node, :height, height, available_h)
+        end
         node.bounds = Bounds.new(x, y, width, height)
+        if node.children.empty?
+          node.cache.shift if node.cache.length >= 5
+          node.cache[key] = true
+          return
+        end
         content = content_bounds(node)
         flow, absolute = node.children.partition { |child| child.style[:position] != :absolute }
-        layout_flow_children(node, content, flow)
+        s = node.style
+        s[:display] == :grid ? layout_grid_children(node, content, flow) : layout_flow_children(node, content, flow)
         layout_absolute_children(absolute, content)
         node.cache.shift if node.cache.length >= 5
         node.cache[key] = true
@@ -90,20 +158,27 @@ module Zaniah
       end
 
       def layout_flow_children(node, content, flow)
-        s = node.style
+        s = node.style.to_h
         row = s[:flex_direction].to_s.start_with?("row")
         reverse = s[:flex_direction].to_s.end_with?("reverse")
         main_size, cross_size = row ? [content.width, content.height] : [content.height, content.width]
         before, after, cross_before, cross_after = row ? [3, 1, 0, 2] : [0, 2, 3, 1]
         main_dimension, cross_dimension = row ? [:width, :height] : [:height, :width]
         gap = resolve_length(s[:gap], main_size, 0)
-        flow = flow.reject { |child| child.style[:display] == :none && hide(child, node.bounds.x, node.bounds.y) }
+        flow = flow.reject { |child| child.style.to_h[:display] == :none && hide(child, node.bounds.x, node.bounds.y) }
+        if s[:flex_wrap] == :nowrap && s[:justify_content] == :start && s[:align_items] == :stretch &&
+            layout_simple_flow(flow, content, row, reverse, main_size, cross_size, cross_dimension, gap)
+          return
+        end
         items = flow.map do |child|
+          style = child.style.to_h
           nw, nh = natural_size(child, content.width, content.height)
-          base = resolve_length(child.style[:flex_basis], main_size, row ? nw : nh)
+          basis = style[:flex_basis]
+          base = resolve_length(basis, main_size, row ? nw : nh)
           margins = resolve_edges(child.style, :margin, content.width)
-          {node: child, base: base, size: clamp_size(child, main_dimension, base, main_size),
-           cross: row ? nh : nw, margins: margins}
+          size = basis == :auto ? base : clamp_size(child, main_dimension, base, main_size)
+          {node: child, base: base, size: size,
+           cross: row ? nh : nw, margins: margins, style: style}
         end
         lines = [[]]
         occupied = 0
@@ -120,7 +195,10 @@ module Zaniah
         cross_cursor = 0
         lines.each do |line|
           next if line.empty?
-          fixed_margin = line.sum { |i| i[:margins].values_at(before, after).sum { |v| v == :auto ? 0 : v } }
+          fixed_margin = line.sum do |item|
+            margins = item[:margins]
+            (margins[before] == :auto ? 0 : margins[before]) + (margins[after] == :auto ? 0 : margins[after])
+          end
           distribute_space(line, main_size - gap * (line.length - 1) - fixed_margin, main_dimension)
           free = main_size - line.sum { |i| i[:size] } - fixed_margin - gap * (line.length - 1)
           autos = line.sum { |i| i[:margins].values_at(before, after).count(:auto) }
@@ -135,16 +213,20 @@ module Zaniah
           else [0, gap]
           end
           line_cross = lines.length == 1 ? cross_size : line.map { |i| i[:cross] + i[:margins].values_at(cross_before, cross_after).sum { |v| v == :auto ? 0 : v } }.max
-          baseline = line.map { |i| i[:node].baseline }.max || 0
+          baseline = line.reduce(0) { |value, item| item[:node].baseline > value ? item[:node].baseline : value }
           cursor = leading
           line.each do |item|
-            child, margins = item.values_at(:node, :margins)
-            mb, ma = margins.values_at(before, after).map { |v| v == :auto ? auto_margin : v }
-            cb, ca = margins.values_at(cross_before, cross_after).map { |v| v == :auto ? 0 : v }
-            align = child.style[:align_self] == :auto ? s[:align_items] : child.style[:align_self]
+            child, margins = item[:node], item[:margins]
+            mb = margins[before] == :auto ? auto_margin : margins[before]
+            ma = margins[after] == :auto ? auto_margin : margins[after]
+            cb = margins[cross_before] == :auto ? 0 : margins[cross_before]
+            ca = margins[cross_after] == :auto ? 0 : margins[cross_after]
+            style = item[:style]
+            align = style[:align_self] == :auto ? s[:align_items] : style[:align_self]
             cross = item[:cross]
-            cross = [line_cross - cb - ca, 0].max if align == :stretch && child.style[cross_dimension] == :auto
-            cross = clamp_size(child, cross_dimension, cross, cross_size)
+            cross = [line_cross - cb - ca, 0].max if align == :stretch && style[cross_dimension] == :auto
+            default_limits = cross_dimension == :width ? style[:min_width] == 0 && style[:max_width] == Float::INFINITY : style[:min_height] == 0 && style[:max_height] == Float::INFINITY
+            cross = clamp_size(child, cross_dimension, cross, cross_size) unless default_limits
             cross_free = line_cross - cross - cb - ca
             cross_offset = case align
             when :end then cross_free
@@ -152,24 +234,79 @@ module Zaniah
             when :baseline then baseline - child.baseline
             else 0
             end
-            cross_autos = margins.values_at(cross_before, cross_after).count(:auto)
+            cross_autos = (margins[cross_before] == :auto ? 1 : 0) + (margins[cross_after] == :auto ? 1 : 0)
             if cross_autos.positive?
               cross_offset = margins[cross_before] == :auto ? [cross_free, 0].max / cross_autos : 0
             end
             cursor += mb
             main_position = reverse ? main_size - cursor - item[:size] : cursor
             cross_position = cross_cursor + cb + cross_offset
-            cx, cy = row ? [content.x + main_position, content.y + cross_position] : [content.x + cross_position, content.y + main_position]
-            cw, ch = row ? [item[:size], cross] : [cross, item[:size]]
-            cx += resolve_length(child.style[:left], content.width, 0) - resolve_length(child.style[:right], content.width, 0)
-            cy += resolve_length(child.style[:top], content.height, 0) - resolve_length(child.style[:bottom], content.height, 0)
-            layout(child, cx, cy, cw, ch, content.width, content.height)
+            if row
+              cx, cy, cw, ch = content.x + main_position, content.y + cross_position, item[:size], cross
+            else
+              cx, cy, cw, ch = content.x + cross_position, content.y + main_position, cross, item[:size]
+            end
+            if style[:left] || style[:right]
+              cx += resolve_length(style[:left], content.width, 0) - resolve_length(style[:right], content.width, 0)
+            end
+            if style[:top] || style[:bottom]
+              cy += resolve_length(style[:top], content.height, 0) - resolve_length(style[:bottom], content.height, 0)
+            end
+            layout(child, cx, cy, cw, ch, content.width, content.height, false)
             cursor += item[:size] + ma + spacing
           end
           cross_cursor += line_cross + gap
         end
       end
 
+      def layout_simple_flow(flow, content, row, reverse, main_size, cross_size, cross_dimension, gap)
+        styles = flow.map { |child| child.style.to_h }
+        return false unless styles.all? do |style|
+          margin = style[:margin]
+          margin.is_a?(Numeric) && margin.zero? && style[:position] == :relative && style[:flex_basis] == :auto &&
+            (style[:align_self] == :auto || style[:align_self] == :stretch) && style[:min_width] == 0 && style[:min_height] == 0 &&
+            style[:max_width] == Float::INFINITY && style[:max_height] == Float::INFINITY &&
+            style[:margin_top].nil? && style[:margin_right].nil? && style[:margin_bottom].nil? && style[:margin_left].nil? &&
+            style[:margin_start].nil? && style[:margin_end].nil? && style[:left].nil? && style[:right].nil? &&
+            style[:top].nil? && style[:bottom].nil? && style[:flex_grow].is_a?(Numeric) && style[:flex_shrink].is_a?(Numeric)
+        end
+
+        bases, crosses = flow.map do |child|
+          width, height = natural_size(child, content.width, content.height)
+          row ? [width, height] : [height, width]
+        end.transpose
+        bases ||= []
+        crosses ||= []
+        available = main_size - gap * [flow.length - 1, 0].max
+        total = bases.sum
+        growing = total < available
+        factor = styles.each_with_index.sum do |style, index|
+          growing ? style[:flex_grow] : style[:flex_shrink] * bases[index]
+        end
+        free = available - total
+        divisor = growing ? [factor, 1].max : factor
+        sizes = bases.each_index.map do |index|
+          weight = growing ? styles[index][:flex_grow] : styles[index][:flex_shrink] * bases[index]
+          bases[index] + (factor.positive? ? free * weight / divisor : 0)
+        end
+        return false if sizes.any?(&:negative?)
+
+        cursor = 0
+        flow.each_with_index do |child, index|
+          style = styles[index]
+          size = sizes[index]
+          cross = style[cross_dimension] == :auto ? cross_size : crosses[index]
+          main_position = reverse ? main_size - cursor - size : cursor
+          if row
+            layout(child, content.x + main_position, content.y, size, cross, content.width, content.height, false)
+          else
+            layout(child, content.x, content.y + main_position, cross, size, content.width, content.height, false)
+          end
+          cursor += size + gap
+        end
+        true
+      end
+
       def layout_absolute_children(children, content)
         children.each do |child|
           nw, nh = natural_size(child, content.width, content.height)
@@ -195,11 +332,11 @@ module Zaniah
         active = line.dup
         remaining = available
         until active.empty?
-          factor = active.sum { |i| growing ? i[:node].style[:flex_grow] : i[:node].style[:flex_shrink] * i[:base] }
+          factor = active.sum { |i| growing ? i[:style][:flex_grow] : i[:style][:flex_shrink] * i[:base] }
           free = remaining - active.sum { |i| i[:base] }
           frozen = []
           active.each do |item|
-            weight = growing ? item[:node].style[:flex_grow] : item[:node].style[:flex_shrink] * item[:base]
+            weight = growing ? item[:style][:flex_grow] : item[:style][:flex_shrink] * item[:base]
             proposed = item[:base] + (factor.positive? ? free * weight / [factor, growing ? 1 : factor].max : 0)
             item[:size] = clamp_size(item[:node], dimension, proposed, available)
             frozen << item if (item[:size] - proposed).abs > 0.00001 || weight.zero?

data/lib/zaniah/layout/grid.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module Zaniah
+  module Layout
+    module GridLayout
+      private
+
+      def layout_grid_children(node, content, children)
+        children = children.reject { |child| child.style[:display] == :none && hide(child, node.bounds.x, node.bounds.y) }
+        columns = Array(node.style[:grid_template_columns]).flatten
+        columns = [:auto] if columns.empty?
+        parsed = children.map do |child|
+          column, column_span = grid_placement(child.style[:grid_column])
+          row, row_span = grid_placement(child.style[:grid_row])
+          {node: child, column: column, column_span: column_span || 1, row: row, row_span: row_span || 1}
+        end
+        column_count = [columns.length, parsed.filter_map { |item| item[:column] && item[:column] + item[:column_span] }.max || 1].max
+        columns += Array.new(column_count - columns.length, :auto)
+        items = place_grid_items(parsed, column_count)
+        row_count = [Array(node.style[:grid_template_rows]).flatten.length,
+          items.map { |item| item[:row] + item[:row_span] }.max || 1].max
+        rows = Array(node.style[:grid_template_rows]).flatten
+        rows += Array.new(row_count - rows.length, :auto)
+        column_gap = resolve_length(node.style[:column_gap] || node.style[:gap], content.width, 0)
+        row_gap = resolve_length(node.style[:row_gap] || node.style[:gap], content.height, 0)
+        natural = items.to_h { |item| [item, natural_size(item[:node], content.width, content.height)] }
+        widths = grid_track_sizes(columns, content.width, column_gap,
+          grid_intrinsic(items, natural, :column, :column_span, 0, column_count))
+        heights = grid_track_sizes(rows, content.height, row_gap,
+          grid_intrinsic(items, natural, :row, :row_span, 1, row_count))
+
+        items.each do |item|
+          column, row = item.values_at(:column, :row)
+          width = widths.slice(column, item[:column_span]).sum + column_gap * (item[:column_span] - 1)
+          height = heights.slice(row, item[:row_span]).sum + row_gap * (item[:row_span] - 1)
+          x = content.x + widths.take(column).sum + column_gap * column
+          y = content.y + heights.take(row).sum + row_gap * row
+          layout(item[:node], x, y, width, height, content.width, content.height)
+        end
+      end
+
+      def grid_placement(value)
+        case value
+        when nil then [nil, nil]
+        when Integer
+          raise ArgumentError, "grid positions start at 1" unless value.positive?
+          [value - 1, 1]
+        when Range
+          first, last = Integer(value.begin), Integer(value.end)
+          last -= 1 if value.exclude_end?
+          raise ArgumentError, "invalid grid range" unless first.positive? && last >= first
+          [first - 1, last - first + 1]
+        else raise ArgumentError, "grid placement must be an Integer or Range"
+        end
+      end
+
+      def place_grid_items(items, columns)
+        occupied = {}
+        cursor = [0, 0]
+        items.each_with_index.sort_by { |item, index| [item[:row] && item[:column] ? 0 : item[:row] || item[:column] ? 1 : 2, index] }.each do |item, _index|
+          explicit = item[:row] || item[:column]
+          row, column = next_grid_cell(occupied, columns, item, cursor)
+          item[:row], item[:column] = row, column
+          item[:row_span].times { |dy| item[:column_span].times { |dx| occupied[[row + dy, column + dx]] = true } }
+          cursor = column + item[:column_span] >= columns ? [row + 1, 0] : [row, column + item[:column_span]] unless explicit
+        end
+        items
+      end
+
+      def next_grid_cell(occupied, columns, item, cursor)
+        column_span, row_span = item.values_at(:column_span, :row_span)
+        raise ArgumentError, "grid item span exceeds column count" if column_span > columns
+        fixed_row, fixed_column = item.values_at(:row, :column)
+        row = fixed_row || (fixed_column ? 0 : cursor[0])
+        column = fixed_column || (fixed_row ? 0 : cursor[1])
+        loop do
+          fits = column + column_span <= columns && row_span.times.all? do |dy|
+            column_span.times.none? { |dx| occupied[[row + dy, column + dx]] }
+          end
+          return [row, column] if fits
+          raise ArgumentError, "grid row is already occupied" if fixed_row && fixed_column
+          if fixed_column
+            row += 1
+          else
+            column += 1
+            row, column = [row + 1, 0] if column + column_span > columns
+            raise ArgumentError, "grid row is already occupied" if fixed_row && row > fixed_row
+          end
+        end
+      end
+
+      def grid_intrinsic(items, natural, start_key, span_key, dimension, count)
+        values = Array.new(count, 0.0)
+        items.each do |item|
+          start, span = item.values_at(start_key, span_key)
+          wanted = natural.fetch(item)[dimension]
+          share = ([wanted - values.slice(start, span).sum, 0].max / span)
+          span.times { |index| values[start + index] += share }
+        end
+        values
+      end
+
+      def grid_track_sizes(specs, available, gap, intrinsic)
+        total = [available - gap * [specs.length - 1, 0].max, 0].max
+        sizes = specs.each_with_index.map { |spec, index| grid_track_min(spec, total, intrinsic[index]) }
+        weights = specs.map { |spec| grid_fraction(spec) }
+        active = weights.each_index.select { |index| weights[index].positive? }
+        remaining = total - sizes.each_index.reject { |index| active.include?(index) }.sum { |index| sizes[index] }
+        until active.empty?
+          unit = remaining / active.sum { |index| weights[index] }
+          constrained = active.select { |index| unit * weights[index] < sizes[index] }
+          if constrained.empty?
+            active.each { |index| sizes[index] = unit * weights[index] }
+            break
+          end
+          constrained.each { |index| remaining -= sizes[index]; active.delete(index) }
+        end
+        sizes
+      end
+
+      def grid_track_min(spec, available, intrinsic)
+        spec = spec.min if spec.is_a?(MinMax)
+        return intrinsic if spec.nil? || spec == :auto
+        return 0.0 if spec.is_a?(Length) && spec.unit == :fr
+        resolve_length(spec, available, 0)
+      end
+
+      def grid_fraction(spec)
+        spec = spec.max if spec.is_a?(MinMax)
+        spec.is_a?(Length) && spec.unit == :fr ? spec.value.to_f : 0.0
+      end
+    end
+  end
+end