hakumi_components 0.1.18.pre → 0.1.19.pre

data/app/components/hakumi_components/table/component.rb

@@ -1,23 +1,41 @@
+# typed: strict
 # frozen_string_literal: true
 
 module HakumiComponents
   module Table
-    # A complex Table component supporting sorting, filtering, selection, expansion, and editing.
     class Component < HakumiComponents::BaseComponent
+      extend T::Sig
+
+      include Concerns::AttributeHelpers
       include Concerns::Columns
       include Concerns::Editable
       include Concerns::FixedColumns
       include Concerns::Ellipsis
+      include Concerns::CellRendering
+      include Concerns::SurfaceRendering
+
+      TableContent = T.type_alias { T.nilable(T.any(Types::Renderable, Proc)) }
+      RowSource = T.type_alias { HakumiComponents::Table::RowRecord::Source }
+      RowKeyConfig = T.type_alias { HakumiComponents::Table::RowRecord::RowKeyConfig }
+      FilterModeValue = T.type_alias { T.nilable(Types::HtmlKey) }
+      FilterSearchValue = T.type_alias { HakumiComponents::Table::DefinitionTypes::SearchValue }
+      ScrollAxisValue = T.type_alias { T.nilable(T.any(String, Numeric)) }
+      ScrollInput = T.type_alias { T.nilable(T::Hash[Types::HtmlKey, ScrollAxisValue]) }
+      RowClassName = T.type_alias { T.nilable(T.any(String, Proc)) }
+      PaginationValue = T.type_alias { HakumiComponents::Table::Configs::Pagination::Value }
+      ControllerLocalScalar = T.type_alias { T.nilable(Types::ValidationPrimitive) }
+      ControllerLocalCollection = T.type_alias { T.any(HakumiComponents::Table::DefinitionTypes::RawCollection, HakumiComponents::Table::DefinitionTypes::RawRecord) }
+      DisplayRow = T.type_alias { { row: HakumiComponents::Table::RowRecord, depth: Integer } }
+      ScrollConfig = T.type_alias { { x: T.nilable(String), y: T.nilable(String) } }
+      ControllerLocalValue = T.type_alias { T.nilable(T.any(ControllerLocalScalar, ControllerLocalCollection)) }
+      ColumnInput = T.type_alias { Concerns::Columns::ColumnInput }
+
+      ROW_SELECTION_TYPES = T.let(%i[checkbox radio].freeze, T::Array[Symbol])
+      SORT_DIRECTIONS = T.let(%i[ascend descend].freeze, T::Array[Symbol])
+      FIXED_SIDES = T.let(%i[left right].freeze, T::Array[Symbol])
+      RESPONSIVE_BREAKPOINTS = T.let(%i[xs sm md lg xl xxl].freeze, T::Array[Symbol])
+      ROW_BUTTON_ACTIONS = T.let(%i[edit save cancel].freeze, T::Array[Symbol])
 
-      # @group Configuration Constants
-      SIZES = %i[default middle small].freeze
-      ROW_SELECTION_TYPES = %i[checkbox radio].freeze
-      SORT_DIRECTIONS = %i[ascend descend].freeze
-      FIXED_SIDES = %i[left right].freeze
-      RESPONSIVE_BREAKPOINTS = %i[xs sm md lg xl xxl].freeze
-      ROW_BUTTON_ACTIONS = %i[edit save cancel].freeze
-
-      # @group Slot Definitions
       SELECTION_COLUMN = :selection_column
       EXPAND_COLUMN = :expand_column
 
@@ -27,7 +45,7 @@ module HakumiComponents
                               sorter: nil, sort_directions: nil, sort_order: nil, default_sort_order: nil,
                               filters: nil, filter_multiple: true, filtered_value: nil, default_filtered_value: nil,
                               filter_mode: nil, filter_search: nil, hidden: false, on_cell: nil, class_name: nil,
-                              **options, &block|
+                              &block|
             HakumiComponents::Table::Column::Component.new(
               title: title,
               data_index: data_index,
@@ -48,31 +66,18 @@ module HakumiComponents
               hidden: hidden,
               on_cell: on_cell,
               class_name: class_name,
-              **options,
               &block
             )
           end,
           as: :column
         },
         group: {
-          renders: lambda do |title:, key: nil, align: nil, width: nil, hidden: false, **options, &block|
-            HakumiComponents::Table::ColumnGroup::Component.new(
-              title: title,
-              key: key,
-              align: align,
-              width: width,
-              hidden: hidden,
-              **options,
-              &block
-            )
-          end,
+          renders: HakumiComponents::Table::ColumnGroup::Component,
           as: :group
         }
       }
 
-      # Extracts local variables for the controller from the params hash.
-      # @param params [Hash] parameters from the request
-      # @return [Hash] hash of local variables
+      sig { params(params: BaseComponent::ControllerOptions).returns(T::Hash[Symbol, ControllerLocalValue]) }
       def self.extract_controller_locals(params)
         {
           columns: parse_json_param(params[:columns]),
@@ -100,7 +105,9 @@ module HakumiComponents
         }
       end
 
+      sig { params(value: BaseComponent::RawHtmlInput).returns(ControllerLocalValue) }
       def self.parse_json_param(value)
+        return value.to_unsafe_h if value.is_a?(ActionController::Parameters)
         return value unless value.is_a?(String)
 
         JSON.parse(value)
@@ -108,6 +115,36 @@ module HakumiComponents
         value
       end
 
+      sig do
+        params(
+          columns: T.nilable(T::Array[ColumnInput]),
+          data_source: T::Array[RowSource],
+          row_key: RowKeyConfig,
+          size: T.nilable(Symbol),
+          bordered: T.nilable(T::Boolean),
+          title: TableContent,
+          footer: TableContent,
+          row_selection: HakumiComponents::Table::Configs::RowSelection::Input,
+          expandable: HakumiComponents::Table::Configs::Expandable::Input,
+          pagination: HakumiComponents::Table::Configs::Pagination::Input,
+          summary: TableContent,
+          empty_text: TableContent,
+          sort_directions: T.nilable(T::Array[Symbol]),
+          filter_on_close: T.nilable(T::Boolean),
+          filter_mode: FilterModeValue,
+          filter_search: FilterSearchValue,
+          children_column_name: HakumiComponents::Table::DefinitionTypes::ColumnKey,
+          indent_size: T.nilable(Integer),
+          scroll: ScrollInput,
+          sticky: T.nilable(T::Boolean),
+          row_class_name: RowClassName,
+          editable: HakumiComponents::Table::Configs::Editable::Input,
+          row_drag: HakumiComponents::Table::Configs::RowDrag::Input,
+          column_drag: T.nilable(T::Boolean),
+          data_url: T.nilable(String),
+          html_options: Types::HtmlAttributeValue
+        ).void
+      end
       def initialize(
         columns: nil,
         data_source: [],
@@ -136,596 +173,298 @@ module HakumiComponents
         data_url: nil,
         **html_options
       )
-        @columns_data = columns
-        @data_source = data_source
-        @row_key = row_key
-        @size = size
-        @bordered = bordered
-        @title = title
-        @footer = footer
-        @row_selection = row_selection
-        @expandable = expandable
-        @pagination = pagination
-        @summary = summary
-        @empty_text = empty_text
-        @sort_directions = Array(sort_directions).presence || SORT_DIRECTIONS
-        @filter_on_close = filter_on_close
-        @filter_mode = filter_mode
-        @filter_search = filter_search
-        @children_column_name = children_column_name
-        @indent_size = indent_size
-        @scroll = normalize_scroll(scroll)
-        @scroll_x = @scroll&.dig(:x)
-        @scroll_y = @scroll&.dig(:y)
-        @sticky = cast_boolean(sticky)
-        @row_class_name = row_class_name
-        @editable = normalize_editable(editable)
-        @row_drag = normalize_row_drag(row_drag)
-        @column_drag = cast_boolean(column_drag)
-        @data_url = data_url
-        @html_options = html_options
-
-        normalize_row_selection!
-        normalize_expandable!
+        @columns_data = T.let(columns, T.nilable(T::Array[ColumnInput]))
+        @data_source = T.let(
+          Array(data_source).map { |row| HakumiComponents::Table::RowRecord.new(source: row, children_column_name: children_column_name) },
+          T::Array[HakumiComponents::Table::RowRecord]
+        )
+        @row_key = T.let(row_key, RowKeyConfig)
+        @size = T.let(size || :default, Symbol)
+        @bordered = T.let(bordered == true, T::Boolean)
+        @title = T.let(title, TableContent)
+        @footer = T.let(footer, TableContent)
+        @row_selection = T.let(HakumiComponents::Table::Configs::RowSelection.coerce(row_selection), T.nilable(HakumiComponents::Table::Configs::RowSelection))
+        @expandable = T.let(HakumiComponents::Table::Configs::Expandable.coerce(expandable), T.nilable(HakumiComponents::Table::Configs::Expandable))
+        @summary = T.let(summary, TableContent)
+        @empty_text = T.let(empty_text, TableContent)
+        @sort_directions = T.let(Array(sort_directions).presence || SORT_DIRECTIONS, T::Array[Symbol])
+        @filter_on_close = T.let(filter_on_close.nil? ? true : filter_on_close, T::Boolean)
+        @filter_mode = T.let(normalize_component_symbol(filter_mode, fallback: :menu), Symbol)
+        @filter_search = T.let(normalize_filter_search(filter_search), HakumiComponents::Table::DefinitionTypes::SearchValue)
+        @children_column_name = T.let(children_column_name, HakumiComponents::Table::DefinitionTypes::ColumnKey)
+        @indent_size = T.let(indent_size || 16, Integer)
+        @scroll = T.let(normalize_scroll(scroll), T.nilable(ScrollConfig))
+        @scroll_x = T.let(@scroll&.dig(:x), T.nilable(String))
+        @scroll_y = T.let(@scroll&.dig(:y), T.nilable(String))
+        @sticky = T.let(sticky == true, T::Boolean)
+        @row_class_name = T.let(row_class_name, RowClassName)
+        @editable = T.let(HakumiComponents::Table::Configs::Editable.coerce(editable), T.nilable(HakumiComponents::Table::Configs::Editable))
+        @row_drag = T.let(HakumiComponents::Table::Configs::RowDrag.coerce(row_drag), T.nilable(HakumiComponents::Table::Configs::RowDrag))
+        @column_drag = T.let(column_drag == true, T::Boolean)
+        @data_url = T.let(data_url, T.nilable(String))
+        @html_options = T.let(html_options, Types::HtmlAttributes)
+        @pagination = T.let(HakumiComponents::Table::Configs::Pagination.coerce(pagination, total: @data_source.size), PaginationValue)
+        @header_rows = T.let(nil, T.nilable(T::Array[T::Array[HakumiComponents::Table::HeaderCell]]))
+        @display_rows = T.let(nil, T.nilable(T::Array[DisplayRow]))
+        @row_render_state = T.let(nil, T.nilable(HakumiComponents::Table::RowRenderState))
 
         validate_props!
       end
 
-      attr_reader :row_selection, :expandable, :pagination, :summary
-
-      def table_classes
-        class_names(
-          "table",
-          {
-            size: @size,
-            bordered: @bordered,
-            empty: display_rows.empty?,
-            sticky: @sticky,
-            scroll_x: @scroll_x.present?,
-            scroll_y: @scroll_y.present?,
-            fixed: fixed_columns?
-          },
-          @html_options[:class]
-        )
+      sig { override.returns(T.nilable(HakumiComponents::Table::Configs::RowSelection)) }
+      def row_selection_config
+        @row_selection
       end
 
-      def table_container_attributes
-        attrs = {
-          class: container_classes,
-          data: {
-            "hakumi--table-target": "scrollContainer"
-          }
-        }
-        styles = scroll_styles
-        attrs[:style] = styles if styles.present?
-        attrs
+      sig { override.returns(T.nilable(HakumiComponents::Table::Configs::Expandable)) }
+      def expandable_config
+        @expandable
       end
 
-      def table_attributes
-        attrs = { class: "hakumi-table-table" }
-        attrs[:style] = table_style if table_style.present?
-        attrs
+      sig { returns(PaginationValue) }
+      def pagination_config
+        @pagination
       end
 
-      def container_classes
-        class_names(
-          "table-container",
-          {
-            scroll_x: @scroll_x.present?,
-            scroll_y: @scroll_y.present?
-          }
-        )
+      sig { override.returns(T.nilable(HakumiComponents::Table::Configs::Editable)) }
+      def table_editable_config
+        @editable
       end
 
-      def wrapper_attributes
-        data_attributes = {
-          controller: "hakumi--table",
-          "hakumi--table-selection-type-value": @row_selection_type,
-          "hakumi--table-selected-row-keys-value": @selected_row_keys.to_json,
-          "hakumi--table-preserve-selected-row-keys-value": @row_selection_preserve,
-          "hakumi--table-sort-directions-value": @sort_directions.join(","),
-          "hakumi--table-filter-on-close-value": @filter_on_close,
-          "hakumi--table-filter-mode-value": @filter_mode,
-          "hakumi--table-filter-search-value": @filter_search
-        }
-        if (editable_json = editable_config_json)
-          data_attributes["hakumi--table-editable-config-value"] = editable_json
-        end
+      sig { override.returns(T.nilable(HakumiComponents::Table::Configs::RowDrag)) }
+      def row_drag_config
+        @row_drag
+      end
 
-        # Server-side pagination/sorting configuration
-        if @pagination.is_a?(Hash)
-          if @pagination[:href]
-            data_attributes["hakumi--table-href-value"] = @pagination[:href]
-            data_attributes["hakumi--table-server-side-value"] = true
-
-            # Add pagination state for preserve_params (sort state from columns)
-            data_attributes["pagination-state"] = true
-            current_sort = current_sort_state
-            if current_sort
-              data_attributes["sort-field"] = current_sort[:field]
-              data_attributes["sort-order"] = current_sort[:order]
-            end
-          end
-          if @pagination[:turbo_frame]
-            data_attributes["hakumi--table-turbo-frame-value"] = @pagination[:turbo_frame]
-          end
-          if @pagination[:sort_field_param]
-            data_attributes["hakumi--table-sort-field-param-value"] = @pagination[:sort_field_param]
-          end
-          if @pagination[:sort_order_param]
-            data_attributes["hakumi--table-sort-order-param-value"] = @pagination[:sort_order_param]
-          end
-        end
+      sig { override.returns(Symbol) }
+      def surface_size
+        @size
+      end
 
-        # Drag sorting configuration
-        if @row_drag
-          data_attributes["hakumi--table-row-drag-value"] = @row_drag[:enabled]
-          data_attributes["hakumi--table-row-drag-handle-value"] = @row_drag[:handle]
-        end
-        if @column_drag
-          data_attributes["hakumi--table-column-drag-value"] = true
-        end
+      sig { override.returns(T::Boolean) }
+      def surface_bordered?
+        @bordered
+      end
 
-        # AJAX data loading configuration
-        if @data_url
-          data_attributes["hakumi--table-data-url-value"] = @data_url
-          data_attributes["hakumi--table-columns-config-value"] = columns_config_json
-          if @pagination.is_a?(Hash)
-            data_attributes["hakumi--table-page-size-value"] = @pagination[:page_size] || 10
-          end
-        end
+      sig { override.returns(T::Boolean) }
+      def surface_sticky?
+        @sticky
+      end
 
-        base = {
-          class: table_classes,
-          data: data_attributes
-        }
-        merge_attributes(base, @html_options)
+      sig { override.returns(T.nilable(String)) }
+      def surface_scroll_x
+        @scroll_x
       end
 
-      def header_rows
-        @header_rows ||= build_header_rows(normalized_columns)
+      sig { override.returns(T.nilable(String)) }
+      def surface_scroll_y
+        @scroll_y
       end
 
-      def display_rows
-        @display_rows ||= build_display_rows
+      sig { override.returns(Types::HtmlAttributes) }
+      def surface_html_options
+        @html_options
       end
 
-      def row_key_for(row, index)
-        case @row_key
-        when Proc
-          @row_key.call(row)
-        when Symbol, String
-          value_from_row(row, @row_key)
-        else
-          row.respond_to?(:[]) ? row[@row_key] : index
-        end
+      sig { override.returns(T.nilable(HakumiComponents::Table::Configs::RowSelection)) }
+      def surface_row_selection
+        @row_selection
       end
 
-      def row_selected?(row_key)
-        @selected_row_keys.include?(row_key.to_s)
+      sig { override.returns(T::Array[Symbol]) }
+      def surface_sort_directions
+        @sort_directions
       end
 
-      def row_classes(row, row_index, row_key)
-        classes = [ "hakumi-table-row" ]
-        classes << "hakumi-table-row-selected" if row_selected?(row_key)
-        classes << "hakumi-table-row-odd" if row_index.odd?
-        if @row_class_name.respond_to?(:call)
-          classes << @row_class_name.call(row, row_index)
-        elsif @row_class_name.is_a?(String)
-          classes << @row_class_name
-        end
-        classes.compact.join(" ")
-      end
-
-      def cell_attributes(column, row, row_index, depth, row_key = nil, raw_value = nil)
-        attrs = {
-          class: cell_classes(column),
-          data: {
-            column_key: column[:key],
-            row_key: row_key,
-            sort_value: extract_sort_value(column, row, raw_value),
-            value: raw_value
-          }.compact
-        }
-        attrs[:style] = "text-align: #{column[:align]};" if column[:align]
-        attrs[:style] = [ attrs[:style], "width: #{column[:width]};" ].compact.join(" ") if column[:width]
-        if column[:on_cell].respond_to?(:call)
-          cell_attrs = column[:on_cell].call(row, row_index)
-          attrs[:colspan] = cell_attrs[:colspan] if cell_attrs
-          attrs[:rowspan] = cell_attrs[:rowspan] if cell_attrs
-          attrs[:class] = [ attrs[:class], cell_attrs[:class] ].compact.join(" ")
-          attrs[:style] = [ attrs[:style], cell_attrs[:style] ].compact.join(" ")
-        end
-        if depth.positive? && column == first_data_column
-          attrs[:style] = [ attrs[:style], "padding-left: #{depth * @indent_size}px;" ].compact.join(" ")
-        end
-        apply_editable_attributes!(attrs, column)
-        apply_should_cell_update_attributes!(attrs, column)
-        apply_fixed_column_attributes!(attrs, column, header: false)
-        attrs
-      end
-
-      def header_cell_attributes(column, col_span:, row_span:)
-        attrs = { class: header_cell_classes(column) }
-        attrs[:colspan] = col_span if col_span > 1
-        attrs[:rowspan] = row_span if row_span > 1
-        attrs[:style] = "text-align: #{column[:align]};" if column[:align]
-        attrs[:style] = [ attrs[:style], "width: #{column[:width]};" ].compact.join(" ") if column[:width]
-        apply_fixed_column_attributes!(attrs, column, header: true)
-        attrs
-      end
-
-      def cell_content(column, row, row_index, raw_value = nil)
-        return selection_cell(row, row_index) if column[:selection]
-        return expand_cell(row, row_index) if column[:expand]
-        return { drag_handle: true } if column[:drag_handle]
-
-        value = raw_value
-        value = value_from_row(row, column[:data_index]) if value.nil? && column[:data_index]
-        if column[:render].respond_to?(:call)
-          column[:render].call(value, row, row_index)
-        else
-          value
-        end
+      sig { override.returns(T::Boolean) }
+      def surface_filter_on_close?
+        @filter_on_close
       end
 
-      def render_cell_display(column, content, raw_value, row, row_index)
-        config = ellipsis_config(column)
+      sig { override.returns(Symbol) }
+      def surface_filter_mode
+        @filter_mode
+      end
 
-        value_fragment = if content.is_a?(ViewComponent::Base)
-          render(content)
-        else
-          content
-        end
-        value_fragment = raw_value if value_fragment.nil?
-
-        span_options = { class: "hakumi-table-cell-content" }
-        title_text = ellipsis_title(config, raw_value, value_fragment)
-        span_options[:title] = title_text if title_text.present?
-
-        display_value = value_fragment.is_a?(Numeric) ? value_fragment.to_s : value_fragment
-        inner = tag.span(**span_options) { display_value }
-
-        tooltip_component = ellipsis_tooltip_component(config, raw_value, row, row_index)
-        tooltip_component ? render(tooltip_component) { inner } : inner
-      end
-
-      def empty_state
-        if @empty_text.present?
-          if @empty_text.is_a?(ViewComponent::Base)
-            render(@empty_text)
-          elsif @empty_text.respond_to?(:call)
-            instance_exec(&@empty_text)
-          else
-            @empty_text
-          end
-        else
-          render(HakumiComponents::Empty::Component.new)
-        end
+      sig { override.returns(HakumiComponents::Table::DefinitionTypes::SearchValue) }
+      def surface_filter_search
+        @filter_search
       end
 
-      def pagination_component
-        return nil unless @pagination
-        return nil if @data_url # AJAX mode uses ajax_pagination_component
-        return @pagination if @pagination.is_a?(ViewComponent::Base)
+      sig { override.returns(T.nilable(HakumiComponents::Table::Configs::Editable)) }
+      def surface_editable
+        @editable
+      end
 
-        options = @pagination.is_a?(Hash) ? @pagination : {}
-        normalized = normalize_pagination_options(options)
-        return nil unless normalized
+      sig { override.returns(T.nilable(HakumiComponents::Table::Configs::RowDrag)) }
+      def surface_row_drag
+        @row_drag
+      end
 
-        HakumiComponents::Pagination::Component.new(**normalized)
+      sig { override.returns(T::Boolean) }
+      def surface_column_drag?
+        @column_drag
       end
 
-      def ajax_pagination_component
-        return nil unless @data_url && @pagination
+      sig { override.returns(PaginationValue) }
+      def surface_pagination
+        @pagination
+      end
 
-        options = @pagination.is_a?(Hash) ? @pagination : {}
-        HakumiComponents::Pagination::Component.new(
-          current: 1,
-          page_size: options[:page_size] || 10,
-          total: 0,
-          show_size_changer: options[:show_size_changer] != false
-        )
+      sig { override.returns(T.nilable(String)) }
+      def surface_data_url
+        @data_url
       end
 
-      def summary_content
-        return nil unless @summary
-        return @summary.call(display_rows.map { |row| row[:row] }) if @summary.respond_to?(:call)
+      sig { override.returns(TableContent) }
+      def surface_empty_text
+        @empty_text
+      end
 
+      sig { override.returns(TableContent) }
+      def surface_summary
         @summary
       end
 
-      def scroll_styles
-        styles = []
-        if @scroll_x
-          styles << "overflow-x: auto"
-        end
-        if @scroll_y
-          styles << "max-height: #{dimension_to_css(@scroll_y)}"
-          styles << "overflow-y: auto"
-        end
-        styles.join("; ")
+      sig { returns(T::Array[T::Array[HakumiComponents::Table::HeaderCell]]) }
+      def header_rows
+        @header_rows ||= build_header_rows(normalized_columns)
       end
 
-      def table_style
-        return nil unless @scroll_x
-
-        "min-width: #{dimension_to_css(@scroll_x)}"
+      sig { override.returns(T::Array[DisplayRow]) }
+      def display_rows
+        @display_rows ||= HakumiComponents::Table::DisplayRows.build(
+          rows: @data_source,
+          pagination: @pagination
+        )
       end
 
-      def selection_column?
-        @row_selection.present?
+      sig { params(row: HakumiComponents::Table::RowRecord, index: Integer).returns(RowSource) }
+      def row_key_for(row, index)
+        row_render_state.row_key_for(row, index)
       end
 
-      def selection_actions?
-        @row_selection.present? && @row_selection_selections
+      sig { params(row_key: RowSource).returns(T::Boolean) }
+      def row_selected?(row_key)
+        row_render_state.selected?(row_key)
       end
 
-      def selection_all_enabled?
-        @row_selection_type == :checkbox
+      sig { params(row: HakumiComponents::Table::RowRecord, row_index: Integer, row_key: RowSource).returns(String) }
+      def row_classes(row, row_index, row_key)
+        row_render_state.row_classes(row, row_index, row_key)
       end
 
+      sig { params(row_key: RowSource).returns(T::Boolean) }
       def expanded_row?(row_key)
-        @expanded_row_keys.include?(row_key.to_s)
+        row_render_state.expanded?(row_key)
       end
 
+      sig { params(row: HakumiComponents::Table::RowRecord, row_index: Integer).returns(RowSource) }
       def expanded_row_content(row, row_index)
-        return nil unless @expandable&.dig(:expanded_row_render).respond_to?(:call)
-
-        @expandable[:expanded_row_render].call(row, row_index)
-      end
-
-      def header_filter_options(column)
-        Array(column[:filters])
+        renderer = @expandable&.expanded_row_render
+        renderer&.call(row.source, row_index)
       end
 
+      sig { override.params(column: HakumiComponents::Table::ColumnDefinition).returns(T::Boolean) }
       def column_sortable?(column)
-        column[:sorter].present?
+        !column.sorter.nil?
       end
 
+      sig { override.params(column: HakumiComponents::Table::ColumnDefinition).returns(T::Boolean) }
       def column_filterable?(column)
-        column[:filters].present?
-      end
-
-      def column_filter_multiple?(column)
-        column[:filter_multiple] != false
+        column.filters.present?
       end
 
+      sig { override.params(column: HakumiComponents::Table::ColumnDefinition).returns(HakumiComponents::Table::DefinitionTypes::ScalarList) }
       def default_filtered_values(column)
-        Array(column[:filtered_value] || column[:default_filtered_value])
+        Array(column.filtered_value || column.default_filtered_value)
       end
 
+      sig { override.params(column: HakumiComponents::Table::ColumnDefinition).returns(T.nilable(Symbol)) }
       def default_sort_order(column)
-        column[:sort_order] || column[:default_sort_order]
-      end
-
-      def current_sort_state
-        sorted_column = leaf_columns.find { |col| default_sort_order(col).present? }
-        return nil unless sorted_column
-
-        {
-          field: sorted_column[:key]&.to_s || sorted_column[:data_index]&.to_s,
-          order: default_sort_order(sorted_column)
-        }
-      end
-
-      def header_cell_classes(column)
-        classes = [ "hakumi-table-cell", "hakumi-table-header-cell" ]
-        classes.concat(responsive_classes(column))
-        classes << "hakumi-table-cell-ellipsis" if ellipsis_config(column)
-        classes << "hakumi-table-cell-sortable" if column_sortable?(column)
-        classes << "hakumi-table-cell-filterable" if column_filterable?(column)
-        classes << column[:class_name] if column[:class_name]
-        classes.compact.join(" ")
-      end
-
-      def cell_classes(column)
-        classes = [ "hakumi-table-cell" ]
-        classes.concat(responsive_classes(column))
-        classes << "hakumi-table-cell-ellipsis" if ellipsis_config(column)
-        classes << "hakumi-table-cell-selection" if column[:selection]
-        classes << "hakumi-table-cell-expand" if column[:expand]
-        classes << column[:class_name] if column[:class_name]
-        classes.compact.join(" ")
-      end
-
-      def selection_header_state
-        total = display_rows.size
-        selected = @selected_row_keys.size
-        {
-          checked: total.positive? && selected == total,
-          indeterminate: selected.positive? && selected < total
-        }
+        column.sort_order || column.default_sort_order
       end
 
       private
 
-      def normalize_row_selection!
-        @selected_row_keys = Array(@row_selection&.dig(:selected_row_keys) || @row_selection&.dig(:selectedRowKeys)).map(&:to_s)
-        @row_selection_type = @row_selection.present? ? (@row_selection&.dig(:type)&.to_sym || :checkbox) : nil
-        @row_selection_preserve = @row_selection&.dig(:preserve_selected_row_keys) || @row_selection&.dig(:preserveSelectedRowKeys) || false
-        @row_selection_selections = @row_selection&.dig(:selections)
-      end
-
-      def normalize_expandable!
-        @expanded_row_keys = Array(@expandable&.dig(:expanded_row_keys) || @expandable&.dig(:expandedRowKeys) || @expandable&.dig(:default_expanded_row_keys) || @expandable&.dig(:defaultExpandedRowKeys)).map(&:to_s)
-        return unless @expandable.present?
-
-        @expandable[:show_expand_column] = true if @expandable[:show_expand_column].nil?
-      end
-
+      sig { void }
       def validate_props!
         validate_inclusion!(:size, SIZES)
-        validate_inclusion!(:row_selection_type, ROW_SELECTION_TYPES) if @row_selection.present?
+        if @row_selection
+          raise ArgumentError, "row_selection type must be one of #{ROW_SELECTION_TYPES.inspect}" unless ROW_SELECTION_TYPES.include?(@row_selection.type)
+        end
         @sort_directions.each do |direction|
           raise ArgumentError, "sort_directions must be one of #{SORT_DIRECTIONS.inspect}" unless SORT_DIRECTIONS.include?(direction)
         end
       end
 
+      sig { params(value: T.nilable(T::Hash[Types::HtmlKey, ScrollAxisValue])).returns(T.nilable(ScrollConfig)) }
       def normalize_scroll(value)
         return nil unless value.is_a?(Hash)
 
         {
-          x: dimension_to_css(value[:x]),
-          y: dimension_to_css(value[:y])
+          x: dimension_to_css(string_or_numeric(value[:x] || value["x"])),
+          y: dimension_to_css(string_or_numeric(value[:y] || value["y"]))
         }.compact.presence
       end
 
-      def responsive_classes(column)
-        responsive = column[:responsive]
-        return [] unless responsive.present?
+      sig { params(value: T.nilable(Types::HtmlKey), fallback: Symbol).returns(Symbol) }
+      def normalize_component_symbol(value, fallback:)
+        return value if value.is_a?(Symbol)
+        return value.to_sym if value.is_a?(String) && value.present?
 
-        responsive.map do |breakpoint|
-          "hakumi-table-col-show-#{breakpoint}"
-        end.prepend("hakumi-table-col-responsive")
-      end
-
-      def extract_sort_value(column, row, raw_value)
-        sort_value_config = column[:sort_value]
-        return raw_value unless sort_value_config
-
-        if sort_value_config.respond_to?(:call)
-          sort_value_config.call(raw_value, row)
-        elsif sort_value_config.is_a?(Symbol) || sort_value_config.is_a?(String)
-          row[sort_value_config.to_sym]
-        else
-          raw_value
-        end
+        fallback
       end
 
-      def normalize_responsive_breakpoints(value)
-        return nil unless value.present?
+      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
 
-        Array(value).map do |breakpoint|
-          sym = breakpoint.to_s.downcase.to_sym
-          sym if RESPONSIVE_BREAKPOINTS.include?(sym)
-        end.compact.presence
-      end
-
-      def normalize_pagination_options(options)
-        normalized = options.symbolize_keys
-
-        total = normalized[:total] || (@data_source.respond_to?(:size) ? @data_source.size : display_rows.size)
-        current = normalized[:current] || 1
-        page_size = normalized[:page_size] || 10
-
-        result = {
-          total: total,
-          current: current,
-          page_size: page_size
-        }
-
-        %i[
-          size align simple show_size_changer show_quick_jumper
-          page_size_options page_param per_page_param href turbo_frame turbo_action
-          show_total hide_on_single_page prev_text next_text preserve_params
-        ].each do |key|
-          result[key] = normalized[key] if normalized.key?(key)
-        end
-
-        result
+        false
       end
 
+      sig { override.returns(T::Array[ColumnInput]) }
       def columns_data
-        return Array(@columns_data) if @columns_data.present?
-        return columns.map(&:to_h) if columns.any?
+        return @columns_data if @columns_data && !@columns_data.empty?
 
-        []
-      end
+        slot_columns = respond_to?(:columns) ? public_send(:columns) : nil
+        return [] unless slot_columns.is_a?(Array) && slot_columns.any?
 
-      def build_display_rows
-        rows = Array(@data_source)
-        rows = flatten_tree(rows)
-        apply_pagination(rows)
-      end
+        slot_columns.filter_map do |column|
+          column_hash = column.respond_to?(:to_h) ? column.to_h : nil
+          next unless column_hash.is_a?(Hash)
 
-      def flatten_tree(rows, depth = 0)
-        rows.flat_map do |row|
-          children = row.respond_to?(:[]) ? row[@children_column_name] || row[@children_column_name.to_s] : nil
-          current = { row: row, depth: depth }
-          if children.respond_to?(:each)
-            [ current, *flatten_tree(children, depth + 1) ]
-          else
-            [ current ]
-          end
+          column_hash
         end
       end
 
-      def apply_pagination(rows)
-        return rows unless @pagination.is_a?(Hash)
-
-        # Skip client-side pagination if data is already paginated server-side
-        return rows if @pagination[:server_side] || @pagination[:href]
-
-        current = @pagination[:current] || @pagination[:page] || 1
-        page_size = @pagination[:page_size] || @pagination[:pageSize] || 10
-        start = (current.to_i - 1) * page_size.to_i
-        rows.slice(start, page_size.to_i) || []
-      end
-
-      def value_from_row(row, data_index)
-        return nil if data_index.nil?
+      sig { override.returns(HakumiComponents::Table::RowRenderState) }
+      def row_render_state
+        state = @row_render_state
+        return state unless state.nil?
 
-        if row.is_a?(Hash)
-          return row[data_index] if row.key?(data_index)
-          return row[data_index.to_s] if row.key?(data_index.to_s)
-        end
-
-        return row.public_send(data_index) if row.respond_to?(data_index)
-
-        nil
+        state = HakumiComponents::Table::RowRenderState.new(
+          row_key: @row_key,
+          row_selection: @row_selection,
+          expandable: @expandable,
+          row_class_name: @row_class_name
+        )
+        @row_render_state = state
       end
 
-      def selection_cell(row, row_index)
-        row_key = row_key_for(row, row_index)
-        {
-          type: @row_selection_type,
-          row_key: row_key,
-          checked: row_selected?(row_key)
-        }
+      sig { override.returns(Integer) }
+      def table_indent_size
+        @indent_size
       end
 
-      def expand_cell(row, row_index)
-        row_key = row_key_for(row, row_index)
-        {
-          row_key: row_key,
-          expanded: expanded_row?(row_key)
-        }
-      end
+      sig { params(value: HakumiComponents::Table::DefinitionTypes::WidthValue).returns(HakumiComponents::Table::DefinitionTypes::WidthValue) }
+      def string_or_numeric(value)
+        return value if value.is_a?(String) || value.is_a?(Numeric)
 
-      # Normalizes row drag configuration.
-      # Can be: true (drag whole row), :handle (drag via handle only), or Hash with options
-      #
-      # @param value [Boolean, Symbol, Hash, nil] row drag configuration
-      # @return [Hash, nil] normalized configuration { enabled: true, handle: false }
-      def normalize_row_drag(value)
-        return nil if value.nil? || value == false
-
-        case value
-        when true
-          { enabled: true, handle: false }
-        when :handle
-          { enabled: true, handle: true }
-        when Hash
-          normalized = value.deep_symbolize_keys
-          {
-            enabled: normalized.fetch(:enabled, true),
-            handle: normalized.fetch(:handle, false)
-          }
-        else
-          nil
-        end
+        nil
       end
 
-      def columns_config_json
-        leaf_columns.map do |col|
-          {
-            key: col[:key],
-            dataIndex: col[:data_index],
-            sorter: col[:sorter].present?
-          }.compact
-        end.to_json
-      end
+      public :columns_data
     end
   end
 end