hakumi_components 0.1.17.pre → 0.1.19.pre

data/app/components/hakumi_components/table/concerns/columns.rb

@@ -0,0 +1,421 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Table
+    module Concerns
+      module Columns
+        extend ActiveSupport::Concern
+        extend T::Sig
+        extend T::Helpers
+
+        abstract!
+
+        ColumnInputValue = T.type_alias { HakumiComponents::Table::DefinitionTypes::DefinitionValue }
+        ColumnInputHash = T.type_alias { HakumiComponents::Table::DefinitionTypes::RawRecord }
+        ColumnInput = T.type_alias { T.any(Symbol, ColumnInputHash) }
+
+        sig { abstract.returns(T::Array[ColumnInput]) }
+        def columns_data; end
+
+        sig { abstract.returns(T.nilable(HakumiComponents::Table::Configs::RowSelection)) }
+        def row_selection_config; end
+
+        sig { abstract.returns(T.nilable(HakumiComponents::Table::Configs::Expandable)) }
+        def expandable_config; end
+
+        sig { abstract.returns(T.nilable(HakumiComponents::Table::Configs::RowDrag)) }
+        def row_drag_config; end
+
+        sig { abstract.params(prefix: String).returns(String) }
+        def generate_id(prefix = ""); end
+
+        sig { abstract.params(value: HakumiComponents::Table::DefinitionTypes::WidthValue).returns(T.nilable(String)) }
+        def dimension_to_css(value); end
+
+        sig { abstract.params(leaf_columns: T::Array[HakumiComponents::Table::ColumnDefinition]).void }
+        def compute_fixed_offsets(leaf_columns); end
+
+        sig { returns(T::Array[HakumiComponents::Table::ColumnDefinition]) }
+        def leaf_columns
+          @leaf_columns = T.let(@leaf_columns, T.nilable(T::Array[HakumiComponents::Table::ColumnDefinition])) if defined?(@leaf_columns)
+          @leaf_columns = T.let(nil, T.nilable(T::Array[HakumiComponents::Table::ColumnDefinition])) unless defined?(@leaf_columns)
+          @leaf_columns ||= flatten_leaf_columns(normalized_columns)
+        end
+
+        sig { returns(Integer) }
+        def leaf_column_count
+          [ leaf_columns.size, 1 ].max
+        end
+
+        sig { returns(T::Boolean) }
+        def selection_column?
+          !row_selection_config.nil?
+        end
+
+        sig { returns(T::Boolean) }
+        def expandable?
+          !expandable_config.nil?
+        end
+
+        sig { returns(T::Boolean) }
+        def expand_column?
+          expandable_config&.show_expand_column == true
+        end
+
+        sig { returns(T::Array[HakumiComponents::Table::ColumnDefinition]) }
+        def normalized_columns
+          @normalized_columns = T.let(@normalized_columns, T.nilable(T::Array[HakumiComponents::Table::ColumnDefinition])) if defined?(@normalized_columns)
+          @normalized_columns = T.let(nil, T.nilable(T::Array[HakumiComponents::Table::ColumnDefinition])) unless defined?(@normalized_columns)
+          @normalized_columns ||= begin
+            columns = normalize_columns(columns_data)
+            columns = insert_drag_handle_column(columns)
+            columns = insert_selection_column(columns)
+            columns = insert_expand_column(columns)
+            columns = columns.compact
+            compute_fixed_offsets(flatten_leaf_columns(columns))
+            columns
+          end
+        end
+
+        private
+
+        sig { params(columns: T::Array[ColumnInput]).returns(T::Array[HakumiComponents::Table::ColumnDefinition]) }
+        def normalize_columns(columns)
+          columns.filter_map do |column|
+            if column == HakumiComponents::Table::Component::SELECTION_COLUMN
+              selection_column_definition
+            elsif column == HakumiComponents::Table::Component::EXPAND_COLUMN
+              expand_column_definition
+            elsif column.is_a?(Hash)
+              normalize_column(column)
+            end
+          end
+        end
+
+        sig { params(column: ColumnInputHash).returns(T.nilable(HakumiComponents::Table::ColumnDefinition)) }
+        def normalize_column(column)
+          normalized = column.deep_symbolize_keys
+          return nil if normalized[:hidden] == true
+
+          key = normalized[:key]
+          data_index = normalized[:data_index]
+          resolved_key = key.is_a?(String) || key.is_a?(Symbol) ? key : data_index
+          resolved_key = generate_id("col") unless resolved_key.is_a?(String) || resolved_key.is_a?(Symbol)
+
+          fixed = normalized[:fixed]
+          fixed = fixed.to_sym if fixed.is_a?(String) || fixed.is_a?(Symbol)
+          fixed = nil unless HakumiComponents::Table::Component::FIXED_SIDES.include?(fixed)
+
+          should_cell_update = normalize_should_cell_update(normalized[:should_cell_update])
+          children_input = normalized[:children]
+          children = children_input.is_a?(Array) ? normalize_columns(children_input.filter_map { |entry| entry.is_a?(Hash) || entry.is_a?(Symbol) ? entry : nil }) : []
+          align = normalized[:align]
+          ellipsis = normalized[:ellipsis]
+          on_cell = normalized[:on_cell]
+          class_name = normalized[:class_name]
+          render = normalized[:render]
+          title = normalize_definition_value(normalized[:title])
+
+          HakumiComponents::Table::ColumnDefinition.new(
+            title: title,
+            key: resolved_key,
+            data_index: data_index.is_a?(String) || data_index.is_a?(Symbol) ? data_index : nil,
+            align: align.is_a?(Symbol) ? align : nil,
+            width: normalize_width(normalized[:width]),
+            ellipsis: normalize_ellipsis_input(ellipsis),
+            sorter: normalize_sorter(normalized[:sorter]),
+            sort_directions: normalize_symbol_array(normalized[:sort_directions]),
+            sort_order: normalize_symbol(normalized[:sort_order]),
+            default_sort_order: normalize_symbol(normalized[:default_sort_order]),
+            filters: normalize_filters(normalized[:filters]),
+            filter_multiple: normalized[:filter_multiple] != false,
+            filtered_value: normalize_scalar_array(normalized[:filtered_value]),
+            default_filtered_value: normalize_scalar_array(normalized[:default_filtered_value]),
+            filter_mode: normalize_symbol(normalized[:filter_mode]),
+            filter_search: normalize_filter_search(normalized[:filter_search]),
+            hidden: false,
+            on_cell: on_cell.is_a?(Proc) ? on_cell : nil,
+            class_name: class_name.is_a?(String) ? class_name : nil,
+            responsive: normalize_responsive_breakpoints(normalized[:responsive]),
+            fixed: fixed.is_a?(Symbol) ? fixed : nil,
+            editable: normalize_column_editable(normalized[:editable]),
+            should_cell_update: should_cell_update,
+            drag_handle: normalized[:drag_handle] == true,
+            selection: normalized[:selection] == true,
+            expand: normalized[:expand] == true,
+            render: render.is_a?(Proc) ? render : nil,
+            sort_value: normalize_sort_value(normalized[:sort_value]),
+            children: children
+          )
+        end
+
+        sig { params(columns: T::Array[HakumiComponents::Table::ColumnDefinition]).returns(T::Array[HakumiComponents::Table::ColumnDefinition]) }
+        def insert_drag_handle_column(columns)
+          return columns unless drag_handle_column?
+          return columns if columns.any?(&:drag_handle?)
+
+          [ drag_handle_column_definition, *columns ]
+        end
+
+        sig { params(columns: T::Array[HakumiComponents::Table::ColumnDefinition]).returns(T::Array[HakumiComponents::Table::ColumnDefinition]) }
+        def insert_selection_column(columns)
+          return columns unless selection_column?
+          return columns if columns.any?(&:selection?)
+
+          [ selection_column_definition, *columns ]
+        end
+
+        sig { params(columns: T::Array[HakumiComponents::Table::ColumnDefinition]).returns(T::Array[HakumiComponents::Table::ColumnDefinition]) }
+        def insert_expand_column(columns)
+          return columns unless expand_column?
+          return columns if columns.any?(&:expand?)
+
+          [ expand_column_definition, *columns ]
+        end
+
+        sig { returns(HakumiComponents::Table::ColumnDefinition) }
+        def selection_column_definition
+          HakumiComponents::Table::ColumnDefinition.new(
+            key: "__selection__",
+            title: "",
+            selection: true,
+            width: "48px",
+            align: :center
+          )
+        end
+
+        sig { returns(HakumiComponents::Table::ColumnDefinition) }
+        def expand_column_definition
+          HakumiComponents::Table::ColumnDefinition.new(
+            key: "__expand__",
+            title: "",
+            expand: true,
+            width: "48px",
+            align: :center
+          )
+        end
+
+        sig { returns(T::Boolean) }
+        def drag_handle_column?
+          row_drag_config&.handle == true
+        end
+
+        sig { returns(HakumiComponents::Table::ColumnDefinition) }
+        def drag_handle_column_definition
+          HakumiComponents::Table::ColumnDefinition.new(
+            key: "__drag__",
+            title: "",
+            drag_handle: true,
+            width: "48px",
+            align: :center
+          )
+        end
+
+        sig { returns(T.nilable(HakumiComponents::Table::ColumnDefinition)) }
+        def first_data_column
+          @first_data_column = T.let(@first_data_column, T.nilable(HakumiComponents::Table::ColumnDefinition)) if defined?(@first_data_column)
+          @first_data_column = T.let(nil, T.nilable(HakumiComponents::Table::ColumnDefinition)) unless defined?(@first_data_column)
+          @first_data_column ||= leaf_columns.find { |column| !column.selection? && !column.expand? && !column.drag_handle? }
+        end
+
+        sig { params(columns: T::Array[HakumiComponents::Table::ColumnDefinition]).returns(T::Array[HakumiComponents::Table::ColumnDefinition]) }
+        def flatten_leaf_columns(columns)
+          columns.flat_map do |column|
+            column.children.empty? ? [ column ] : flatten_leaf_columns(column.children)
+          end
+        end
+
+        sig { params(columns: T::Array[HakumiComponents::Table::ColumnDefinition]).returns(Integer) }
+        def leaf_count(columns)
+          columns.sum { |column| column.children.empty? ? 1 : leaf_count(column.children) }
+        end
+
+        sig { params(columns: T::Array[HakumiComponents::Table::ColumnDefinition], depth: Integer).returns(Integer) }
+        def max_depth(columns, depth = 1)
+          columns.map do |column|
+            column.children.empty? ? depth : max_depth(column.children, depth + 1)
+          end.max || depth
+        end
+
+        sig { params(columns: T::Array[HakumiComponents::Table::ColumnDefinition]).returns(T::Array[T::Array[HakumiComponents::Table::HeaderCell]]) }
+        def build_header_rows(columns)
+          depth = max_depth(columns)
+          rows = T.let(Array.new(depth) { [] }, T::Array[T::Array[HakumiComponents::Table::HeaderCell]])
+          build_rows_recursive(columns, 0, rows, depth)
+          rows
+        end
+
+        sig { params(columns: T::Array[HakumiComponents::Table::ColumnDefinition], level: Integer, rows: T::Array[T::Array[HakumiComponents::Table::HeaderCell]], max_depth: Integer).void }
+        def build_rows_recursive(columns, level, rows, max_depth)
+          row = rows[level]
+          return if row.nil?
+
+          columns.each do |column|
+            if column.children.empty?
+              row << HakumiComponents::Table::HeaderCell.new(column: column, col_span: 1, row_span: max_depth - level)
+            else
+              row << HakumiComponents::Table::HeaderCell.new(column: column, col_span: leaf_count(column.children), row_span: 1)
+              build_rows_recursive(column.children, level + 1, rows, max_depth)
+            end
+          end
+        end
+
+        sig { params(value: HakumiComponents::Table::DefinitionTypes::RawEntry).returns(HakumiComponents::Table::DefinitionTypes::WidthValue) }
+        def normalize_width(value)
+          return value if value.is_a?(String) || value.is_a?(Numeric)
+          nil
+        end
+
+        sig { params(value: HakumiComponents::Table::DefinitionTypes::RawEntry).returns(HakumiComponents::Table::DefinitionTypes::SorterValue) }
+        def normalize_sorter(value)
+          return value if value.is_a?(String) || value.is_a?(Symbol) || value == true || value == false
+
+          nil
+        end
+
+        sig { params(value: HakumiComponents::Table::DefinitionTypes::RawEntry).returns(T.nilable(T::Array[Symbol])) }
+        def normalize_symbol_array(value)
+          return nil unless value.is_a?(Array)
+
+          entries = value.filter_map { |entry| entry.is_a?(String) || entry.is_a?(Symbol) ? entry.to_sym : nil }
+          entries.presence
+        end
+
+        sig { params(value: HakumiComponents::Table::DefinitionTypes::RawEntry).returns(T.nilable(Symbol)) }
+        def normalize_symbol(value)
+          return value if value.is_a?(Symbol)
+          return value.to_sym if value.is_a?(String) && value.present?
+
+          nil
+        end
+
+        sig { params(value: HakumiComponents::Table::DefinitionTypes::RawEntry).returns(HakumiComponents::Table::DefinitionTypes::SearchValue) }
+        def normalize_filter_search(value)
+          return value if value.is_a?(String) || value.is_a?(Symbol) || value == true || value == false
+
+          nil
+        end
+
+        sig { params(value: HakumiComponents::Table::DefinitionTypes::RawEntry).returns(T.nilable(HakumiComponents::Table::DefinitionTypes::ScalarList)) }
+        def normalize_scalar_array(value)
+          return nil unless value.is_a?(Array)
+
+          entries = value.filter_map do |entry|
+            entry if entry.is_a?(String) || entry.is_a?(Symbol) || entry.is_a?(Numeric)
+          end
+          entries.presence
+        end
+
+        sig { params(value: HakumiComponents::Table::DefinitionTypes::RawEntry).returns(T.nilable(String)) }
+        def normalize_should_cell_update(value)
+          case value
+          when Symbol
+            value.to_s
+          when String
+            value.strip.presence
+          end
+        end
+
+        sig { params(value: HakumiComponents::Table::DefinitionTypes::RawEntry).returns(HakumiComponents::Table::DefinitionTypes::SortValue) }
+        def normalize_sort_value(value)
+          return value if value.is_a?(String) || value.is_a?(Symbol) || value.is_a?(Proc)
+
+          nil
+        end
+
+        sig { params(value: HakumiComponents::Table::DefinitionTypes::RawEntry).returns(T.nilable(HakumiComponents::Table::DefinitionTypes::DefinitionValue)) }
+        def normalize_definition_value(value)
+          return value if value.nil? || value.is_a?(String) || value.is_a?(Symbol) || value.is_a?(Numeric) || value == true || value == false || value.is_a?(Proc)
+          return normalize_definition_array(value) if value.is_a?(Array)
+          return normalize_definition_hash(value) if value.is_a?(Hash)
+
+          nil
+        end
+
+        sig { params(value: HakumiComponents::Table::DefinitionTypes::RawEntry).returns(T.nilable(HakumiComponents::Table::Configs::ColumnEditable)) }
+        def normalize_column_editable(value)
+          return nil unless value.is_a?(Hash) || value == true || value == false || value.is_a?(HakumiComponents::Table::Configs::ColumnEditable)
+
+          HakumiComponents::Table::Configs::ColumnEditable.coerce(value)
+        end
+
+        sig { params(value: HakumiComponents::Table::DefinitionTypes::RawEntry).returns(T.nilable(T::Array[HakumiComponents::Table::DefinitionTypes::DefinitionHash])) }
+        def normalize_filters(value)
+          return nil unless value.is_a?(Array)
+
+          filters = value.filter_map do |entry|
+            next unless entry.is_a?(Hash)
+
+            normalized = entry.deep_symbolize_keys
+            filter = T.let({}, HakumiComponents::Table::DefinitionTypes::DefinitionHash)
+            normalized.each do |key, item|
+              normalized_item = normalize_definition_value(item)
+              next if normalized_item.nil? && !item.nil?
+
+              filter[key] = normalized_item
+            end
+            filter
+          end
+          filters.presence
+        end
+
+        sig { params(value: HakumiComponents::Table::DefinitionTypes::RawEntry).returns(T.nilable(T::Array[Symbol])) }
+        def normalize_responsive_breakpoints(value)
+          return nil if value.nil?
+
+          breakpoints = Array(value).filter_map do |breakpoint|
+            sym = breakpoint.to_s.downcase.to_sym
+            sym if HakumiComponents::Table::Component::RESPONSIVE_BREAKPOINTS.include?(sym)
+          end
+          breakpoints.presence
+        end
+
+        sig { params(value: HakumiComponents::Table::DefinitionTypes::RawEntry).returns(T.nilable(HakumiComponents::Table::EllipsisConfig)) }
+        def normalize_ellipsis_input(value)
+          return nil unless value == true || value == false || value.is_a?(String) || value.is_a?(Hash)
+
+          normalized = if value.is_a?(Hash)
+            value.each_with_object(T.let({}, HakumiComponents::Table::EllipsisConfig::InputHash)) do |(key, entry), result|
+              next unless key.is_a?(String) || key.is_a?(Symbol)
+
+              coerced_entry = normalize_definition_value(entry)
+              next if coerced_entry.nil? && !entry.nil?
+
+              result[key] = coerced_entry
+            end
+          else
+            value
+          end
+
+          HakumiComponents::Table::EllipsisConfig.from_input(normalized)
+        end
+
+        sig { params(value: HakumiComponents::Table::DefinitionTypes::RawCollection).returns(HakumiComponents::Table::DefinitionTypes::RawCollection) }
+        def normalize_definition_array(value)
+          normalized = T.let([], HakumiComponents::Table::DefinitionTypes::RawCollection)
+          value.each do |entry|
+            next unless entry.is_a?(String) || entry.is_a?(Symbol) || entry.is_a?(Numeric) || entry == true || entry == false || entry.is_a?(Proc)
+
+            normalized << entry
+          end
+          normalized
+        end
+
+        sig { params(value: HakumiComponents::Table::DefinitionTypes::RawRecord).returns(HakumiComponents::Table::DefinitionTypes::DefinitionHash) }
+        def normalize_definition_hash(value)
+          normalized = T.let({}, HakumiComponents::Table::DefinitionTypes::DefinitionHash)
+          value.each do |key, entry|
+            next unless key.is_a?(String) || key.is_a?(Symbol)
+
+            normalized_entry = normalize_definition_value(entry)
+            next if normalized_entry.nil? && !entry.nil?
+
+            normalized[key.to_sym] = normalized_entry
+          end
+          normalized
+        end
+      end
+    end
+  end
+end

data/app/components/hakumi_components/table/concerns/editable.rb

@@ -0,0 +1,68 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Table
+    module Concerns
+      module Editable
+        extend ActiveSupport::Concern
+        extend T::Sig
+        extend T::Helpers
+
+        include AttributeHelpers
+
+        abstract!
+
+        sig { abstract.returns(T.nilable(HakumiComponents::Table::Configs::Editable)) }
+        def table_editable_config; end
+
+        sig { returns(T.nilable(String)) }
+        def editable_config_json
+          config = table_editable_config
+          config ? config.to_h.to_json : nil
+        end
+
+        private
+
+        sig { params(attrs: Types::HtmlAttributes, column: HakumiComponents::Table::ColumnDefinition).void }
+        def apply_editable_attributes!(attrs, column)
+          payload = cell_editable_payload(column)
+          return unless payload
+
+          attrs[:class] = [ attrs[:class], "hakumi-table-cell-editable" ].compact.join(" ")
+          data_attrs = existing_data_attributes(attrs)
+          data_attrs[:editable] = true
+          data_attrs[:editable_config] = payload.to_json
+          data_attrs[:action] = payload[:trigger] == :dblclick ? "dblclick->hakumi--table#editCell" : "click->hakumi--table#editCell"
+          attrs[:data] = data_attrs
+        end
+
+        sig { params(attrs: Types::HtmlAttributes, column: HakumiComponents::Table::ColumnDefinition).void }
+        def apply_should_cell_update_attributes!(attrs, column)
+          hook = column.should_cell_update
+          return unless hook.present?
+
+          data_attrs = existing_data_attributes(attrs)
+          data_attrs[:should_cell_update] = hook
+          attrs[:data] = data_attrs
+        end
+
+        sig { params(column: HakumiComponents::Table::ColumnDefinition).returns(T.nilable(HakumiComponents::Table::Configs::Editable::Payload)) }
+        def cell_editable_payload(column)
+          return nil if column.selection? || column.expand?
+          data_index = column.data_index
+          return nil if data_index.nil?
+
+          column_config = column.editable
+          return nil unless column_config
+
+          base_config = table_editable_config&.to_h || { mode: :cell, trigger: :click }
+          payload = T.let(base_config.merge(column_config.to_h), HakumiComponents::Table::Configs::Editable::Payload)
+          payload[:data_index] = data_index
+          payload[:key] = column.key
+          payload
+        end
+      end
+    end
+  end
+end

data/app/components/hakumi_components/table/concerns/ellipsis.rb

@@ -0,0 +1,64 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Table
+    module Concerns
+      module Ellipsis
+        extend ActiveSupport::Concern
+        extend T::Sig
+
+        private
+
+        sig { params(column: HakumiComponents::Table::ColumnDefinition).returns(T.nilable(HakumiComponents::Table::EllipsisConfig)) }
+        def ellipsis_config(column)
+          value = column.ellipsis
+          value.is_a?(HakumiComponents::Table::EllipsisConfig) ? value : nil
+        end
+
+        sig { params(option: HakumiComponents::Table::EllipsisConfig::Input).returns(T.nilable(HakumiComponents::Table::EllipsisConfig)) }
+        def normalize_ellipsis_option(option)
+          HakumiComponents::Table::EllipsisConfig.from_input(option)
+        end
+
+        sig do
+          params(
+            config: T.nilable(HakumiComponents::Table::EllipsisConfig),
+            raw_value: HakumiComponents::Table::RowRecord::Source,
+            content_fragment: T.untyped
+          ).returns(T.nilable(String))
+        end
+        def ellipsis_title(config, raw_value, content_fragment)
+          return nil unless config&.show_title
+
+          value = raw_value.nil? ? content_fragment : raw_value
+          return nil if value.nil?
+
+          text = value.to_s
+          text.empty? ? nil : text
+        end
+
+        sig do
+          params(
+            config: T.nilable(HakumiComponents::Table::EllipsisConfig),
+            raw_value: HakumiComponents::Table::RowRecord::Source,
+            row: HakumiComponents::Table::RowRecord::Source,
+            row_index: Integer
+          ).returns(T.nilable(HakumiComponents::Tooltip::Component))
+        end
+        def ellipsis_tooltip_component(config, raw_value, row, row_index)
+          return nil unless config.is_a?(HakumiComponents::Table::EllipsisConfig::WithTooltip)
+
+          options = config.tooltip.options.deep_dup
+          title = config.tooltip.title
+          title ||= raw_value
+          title = title.call(row, row_index) if title.is_a?(Proc)
+          title = title.to_s if title.respond_to?(:to_s)
+          return nil if title.blank?
+
+          HakumiComponents::Tooltip::Component.new(**{ title: title }.merge(options))
+        end
+      end
+    end
+  end
+end

data/app/components/hakumi_components/table/concerns/fixed_columns.rb

@@ -0,0 +1,94 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Table
+    module Concerns
+      module FixedColumns
+        extend ActiveSupport::Concern
+        extend T::Sig
+
+        include AttributeHelpers
+
+        sig { returns(T::Boolean) }
+        def fixed_columns?
+          fixed_offsets.present?
+        end
+
+        private
+
+        sig { returns(T::Hash[Types::HtmlKey, HakumiComponents::Table::FixedOffset]) }
+        def fixed_offsets
+          @fixed_offsets = T.let(@fixed_offsets, T.nilable(T::Hash[Types::HtmlKey, HakumiComponents::Table::FixedOffset])) if defined?(@fixed_offsets)
+          @fixed_offsets = T.let(nil, T.nilable(T::Hash[Types::HtmlKey, HakumiComponents::Table::FixedOffset])) unless defined?(@fixed_offsets)
+          @fixed_offsets ||= {}
+        end
+
+        sig { params(attrs: Types::HtmlAttributes, column: HakumiComponents::Table::ColumnDefinition, header: T::Boolean).void }
+        def apply_fixed_column_attributes!(attrs, column, header: false)
+          info = fixed_offsets[column.key]
+          return unless info
+
+          attrs[:class] = [ attrs[:class], "hakumi-table-cell-fixed", "hakumi-table-cell-fixed-#{info.side}" ].compact.join(" ")
+
+          style_parts = Array.new
+          style_parts << attrs[:style] if attrs[:style].present?
+          style_parts << "position: sticky"
+          style_parts << "#{info.side}: #{info.offset}px"
+          style_parts << "z-index: #{header ? 3 : 2}"
+          attrs[:style] = style_parts.compact.join("; ")
+
+          data_attrs = existing_data_attributes(attrs)
+          data_attrs[:fixed] = info.side
+          attrs[:data] = data_attrs
+        end
+
+        sig { params(leaf_columns: T::Array[HakumiComponents::Table::ColumnDefinition]).void }
+        def compute_fixed_offsets(leaf_columns)
+          @fixed_offsets = {}
+          return if leaf_columns.blank?
+
+          left_offset = T.let(0.0, Float)
+          leaf_columns.each do |column|
+            next unless column.fixed == :left
+
+            width = fixed_column_width!(column)
+            @fixed_offsets[column.key] = HakumiComponents::Table::FixedOffset.new(side: :left, offset: left_offset)
+            left_offset += width
+          end
+
+          right_offset = T.let(0.0, Float)
+          leaf_columns.reverse_each do |column|
+            next unless column.fixed == :right
+
+            width = fixed_column_width!(column)
+            @fixed_offsets[column.key] = HakumiComponents::Table::FixedOffset.new(side: :right, offset: right_offset)
+            right_offset += width
+          end
+        end
+
+        sig { params(column: HakumiComponents::Table::ColumnDefinition).returns(Float) }
+        def fixed_column_width!(column)
+          width = numeric_width(column.width)
+          return width if width&.positive?
+
+          raise ArgumentError, "Column #{column.key} must define a pixel width when fixed"
+        end
+
+        sig { params(value: T.nilable(T.any(String, Numeric))).returns(T.nilable(Float)) }
+        def numeric_width(value)
+          case value
+          when Integer, Float
+            value.to_f
+          when String
+            stripped = value.strip
+            return stripped.to_f if stripped.match?(/\A[\d.]+\z/)
+
+            match = stripped.match(/\A([\d.]+)px\z/i)
+            match ? match[1].to_f : nil
+          end
+        end
+      end
+    end
+  end
+end