hakumi_components 0.1.17.pre → 0.1.19.pre

data/app/components/{hakumi → hakumi_components}/table/component.html.erb

@@ -7,9 +7,9 @@
 
   <% if selection_actions? %>
     <div class="hakumi-table-selection-actions">
-      <button type="button" data-action="click->hakumi--table#selectAll">Select all</button>
-      <button type="button" data-action="click->hakumi--table#invertSelection">Invert</button>
-      <button type="button" data-action="click->hakumi--table#clearSelection">Clear</button>
+      <button type="button" data-action="click->hakumi--table#selectAll"><%= select_all_text %></button>
+      <button type="button" data-action="click->hakumi--table#invertSelection"><%= invert_text %></button>
+      <button type="button" data-action="click->hakumi--table#clearSelection"><%= clear_text %></button>
     </div>
   <% end %>
 
@@ -19,19 +19,10 @@
         <% header_rows.each do |row| %>
           <tr class="hakumi-table-header-row">
             <% row.each do |cell| %>
-              <% column = cell[:column] %>
-              <th <%= tag.attributes(header_cell_attributes(column, col_span: cell[:col_span], row_span: cell[:row_span])) %>
-                  data-column-key="<%= column[:key] %>"
-                  data-field="<%= column[:data_index] %>"
-                  <% if column[:sort_value] %>data-sort-field="<%= column[:sort_value] %>"<% end %>
-                  <% if column_sortable?(column) %>data-action="click->hakumi--table#toggleSort"<% end %>
-                  <% if column_filterable?(column) %>data-hakumi--table-target="filterToggle"<% end %>
-                  data-sortable="<%= column_sortable?(column) %>"
-                  data-filterable="<%= column_filterable?(column) %>"
-                  data-default-sort="<%= default_sort_order(column) %>"
-                  data-default-filter="<%= default_filtered_values(column).to_json %>">
+              <% column = cell.column %>
+              <th <%= tag.attributes(header_cell_attributes(column, col_span: cell.col_span, row_span: cell.row_span)) %>>
                 <div class="hakumi-table-header-cell-content">
-                  <% if column[:selection] && selection_all_enabled? %>
+                  <% if column.selection? && selection_all_enabled? %>
                     <% header_state = selection_header_state %>
                     <input type="checkbox"
                            class="hakumi-table-selection-input"
@@ -39,13 +30,13 @@
                            data-action="change->hakumi--table#toggleAll"
                            <%= "checked" if header_state[:checked] %>
                            <%= "data-indeterminate=true" if header_state[:indeterminate] %>>
-                  <% elsif column[:expand] %>
+                  <% elsif column.expand? %>
                     <span class="hakumi-table-header-title"></span>
-                  <% elsif column[:drag_handle] %>
+                  <% elsif column.drag_handle? %>
                     <span class="hakumi-table-header-title"></span>
                   <% else %>
                     <span class="hakumi-table-header-title">
-                      <%= column[:title].respond_to?(:call) ? column[:title].call : column[:title] %>
+                      <%= column.title.respond_to?(:call) ? column.title.call : column.title %>
                     </span>
                   <% end %>
                   <% if column_sortable?(column) %>
@@ -59,10 +50,10 @@
                       <summary class="hakumi-table-filter-trigger" data-action="click->hakumi--table#toggleFilter">
                         <span class="hakumi-table-filter-icon" aria-hidden="true"></span>
                       </summary>
-                      <div class="hakumi-table-filter-dropdown" data-hakumi--table-target="filterDropdown" data-column-key="<%= column[:key] %>" data-filter-multiple="<%= column_filter_multiple?(column) %>">
-                        <% if @filter_search || column[:filter_search] %>
+                      <div class="hakumi-table-filter-dropdown" data-hakumi--table-target="filterDropdown" data-column-key="<%= column.key %>" data-filter-multiple="<%= column_filter_multiple?(column) %>">
+                        <% if @filter_search || column.filter_search %>
                           <div class="hakumi-table-filter-search">
-                            <input type="text" placeholder="Search" data-action="input->hakumi--table#filterSearch" data-hakumi--table-target="filterSearch">
+                            <input type="text" placeholder="<%= search_placeholder_text %>" data-action="input->hakumi--table#filterSearch" data-hakumi--table-target="filterSearch">
                           </div>
                         <% end %>
                         <div class="hakumi-table-filter-options">
@@ -72,7 +63,7 @@
                             <label class="hakumi-table-filter-option">
                               <input
                                 type="<%= column_filter_multiple?(column) ? 'checkbox' : 'radio' %>"
-                                name="filter-<%= column[:key] %>"
+                                name="filter-<%= column.key %>"
                                 value="<%= value %>"
                                 data-action="change->hakumi--table#applyFilters"
                                 data-hakumi--table-target="filterOption"
@@ -82,7 +73,7 @@
                           <% end %>
                         </div>
                         <div class="hakumi-table-filter-actions">
-                          <button type="button" class="hakumi-table-filter-clear" data-action="click->hakumi--table#clearFilters">Reset</button>
+                          <button type="button" class="hakumi-table-filter-clear" data-action="click->hakumi--table#clearFilters"><%= reset_text %></button>
                           <button type="button" class="hakumi-table-filter-confirm" data-action="click->hakumi--table#confirmFilters">OK</button>
                         </div>
                       </div>
@@ -96,19 +87,19 @@
       </thead>
       <tbody class="hakumi-table-tbody">
         <% if display_rows.any? %>
-          <% display_rows.each_with_index do |row_data, index| %>
-            <% row = row_data[:row] %>
-            <% depth = row_data[:depth] %>
-            <% row_key = row_key_for(row, index) %>
+            <% display_rows.each_with_index do |row_data, index| %>
+              <% row = row_data[:row] %>
+              <% depth = row_data[:depth] %>
+              <% row_key = row_key_for(row, index) %>
             <tr class="<%= row_classes(row, index, row_key) %>"
                 data-hakumi--table-target="row"
                 data-row-key="<%= row_key %>"
                 data-row-type="data">
               <% leaf_columns.each do |column| %>
-                <% raw_value = column[:data_index] ? value_from_row(row, column[:data_index]) : nil %>
+                <% raw_value = column.data_index ? row.value(column.data_index) : nil %>
                 <% attrs = cell_attributes(column, row, index, depth, row_key, raw_value) %>
                 <% next if attrs[:colspan] == 0 || attrs[:rowspan] == 0 %>
-                <td <%= tag.attributes(attrs) %> data-sort-value="<%= raw_value %>">
+                <td <%= tag.attributes(attrs) %>>
                   <% content = cell_content(column, row, index, raw_value) %>
                   <% if content.is_a?(Hash) && content[:drag_handle] %>
                     <span class="hakumi-table-drag-handle" data-hakumi--table-target="dragHandle">
@@ -127,7 +118,7 @@
                       <%= "checked" if content[:checked] %>>
                   <% elsif content.is_a?(Hash) && content[:row_key] %>
                     <button type="button"
-                            class="hakumi-table-expand-button <%= 'is-expanded' if content[:expanded] %>"
+                            class="hakumi-table-expand-button <%= 'hakumi-table-expand-button-expanded' if content[:expanded] %>"
                             data-hakumi--table-target="expandToggle"
                             data-action="click->hakumi--table#toggleExpand"
                             data-row-key="<%= content[:row_key] %>"
@@ -142,7 +133,7 @@
             </tr>
             <% if expandable? %>
               <% expanded_content = expanded_row_content(row, index) %>
-              <tr class="hakumi-table-expanded-row <%= "is-expanded" if expanded_row?(row_key) %>"
+              <tr class="hakumi-table-expanded-row <%= "hakumi-table-row-expanded" if expanded_row?(row_key) %>"
                   data-row-key="<%= row_key %>"
                   data-row-type="expanded"
                   <%= "hidden" unless expanded_row?(row_key) %>>

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

@@ -0,0 +1,470 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Table
+    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])
+
+      SELECTION_COLUMN = :selection_column
+      EXPAND_COLUMN = :expand_column
+
+      renders_many :columns, types: {
+        column: {
+          renders: lambda do |title:, data_index: nil, key: nil, align: nil, width: nil, ellipsis: false,
+                              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,
+                              &block|
+            HakumiComponents::Table::Column::Component.new(
+              title: title,
+              data_index: data_index,
+              key: key,
+              align: align,
+              width: width,
+              ellipsis: ellipsis,
+              sorter: sorter,
+              sort_directions: sort_directions,
+              sort_order: sort_order,
+              default_sort_order: default_sort_order,
+              filters: filters,
+              filter_multiple: filter_multiple,
+              filtered_value: filtered_value,
+              default_filtered_value: default_filtered_value,
+              filter_mode: filter_mode,
+              filter_search: filter_search,
+              hidden: hidden,
+              on_cell: on_cell,
+              class_name: class_name,
+              &block
+            )
+          end,
+          as: :column
+        },
+        group: {
+          renders: HakumiComponents::Table::ColumnGroup::Component,
+          as: :group
+        }
+      }
+
+      sig { params(params: BaseComponent::ControllerOptions).returns(T::Hash[Symbol, ControllerLocalValue]) }
+      def self.extract_controller_locals(params)
+        {
+          columns: parse_json_param(params[:columns]),
+          data_source: parse_json_param(params[:data_source]),
+          row_key: params[:row_key],
+          size: params[:size],
+          bordered: params[:bordered],
+          title: params[:title],
+          footer: params[:footer],
+          row_selection: params[:row_selection],
+          expandable: params[:expandable],
+          pagination: params[:pagination],
+          summary: params[:summary],
+          empty_text: params[:empty_text],
+          sort_directions: params[:sort_directions],
+          filter_on_close: params[:filter_on_close],
+          filter_mode: params[:filter_mode],
+          filter_search: params[:filter_search],
+          children_column_name: params[:children_column_name],
+          indent_size: params[:indent_size],
+          scroll: params[:scroll],
+          sticky: params[:sticky],
+          row_class_name: params[:row_class_name],
+          editable: parse_json_param(params[:editable])
+        }
+      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)
+      rescue JSON::ParserError
+        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: [],
+        row_key: :key,
+        size: :default,
+        bordered: false,
+        title: nil,
+        footer: nil,
+        row_selection: nil,
+        expandable: nil,
+        pagination: nil,
+        summary: nil,
+        empty_text: nil,
+        sort_directions: SORT_DIRECTIONS,
+        filter_on_close: true,
+        filter_mode: :menu,
+        filter_search: false,
+        children_column_name: :children,
+        indent_size: 16,
+        scroll: nil,
+        sticky: false,
+        row_class_name: nil,
+        editable: nil,
+        row_drag: nil,
+        column_drag: false,
+        data_url: nil,
+        **html_options
+      )
+        @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
+
+      sig { override.returns(T.nilable(HakumiComponents::Table::Configs::RowSelection)) }
+      def row_selection_config
+        @row_selection
+      end
+
+      sig { override.returns(T.nilable(HakumiComponents::Table::Configs::Expandable)) }
+      def expandable_config
+        @expandable
+      end
+
+      sig { returns(PaginationValue) }
+      def pagination_config
+        @pagination
+      end
+
+      sig { override.returns(T.nilable(HakumiComponents::Table::Configs::Editable)) }
+      def table_editable_config
+        @editable
+      end
+
+      sig { override.returns(T.nilable(HakumiComponents::Table::Configs::RowDrag)) }
+      def row_drag_config
+        @row_drag
+      end
+
+      sig { override.returns(Symbol) }
+      def surface_size
+        @size
+      end
+
+      sig { override.returns(T::Boolean) }
+      def surface_bordered?
+        @bordered
+      end
+
+      sig { override.returns(T::Boolean) }
+      def surface_sticky?
+        @sticky
+      end
+
+      sig { override.returns(T.nilable(String)) }
+      def surface_scroll_x
+        @scroll_x
+      end
+
+      sig { override.returns(T.nilable(String)) }
+      def surface_scroll_y
+        @scroll_y
+      end
+
+      sig { override.returns(Types::HtmlAttributes) }
+      def surface_html_options
+        @html_options
+      end
+
+      sig { override.returns(T.nilable(HakumiComponents::Table::Configs::RowSelection)) }
+      def surface_row_selection
+        @row_selection
+      end
+
+      sig { override.returns(T::Array[Symbol]) }
+      def surface_sort_directions
+        @sort_directions
+      end
+
+      sig { override.returns(T::Boolean) }
+      def surface_filter_on_close?
+        @filter_on_close
+      end
+
+      sig { override.returns(Symbol) }
+      def surface_filter_mode
+        @filter_mode
+      end
+
+      sig { override.returns(HakumiComponents::Table::DefinitionTypes::SearchValue) }
+      def surface_filter_search
+        @filter_search
+      end
+
+      sig { override.returns(T.nilable(HakumiComponents::Table::Configs::Editable)) }
+      def surface_editable
+        @editable
+      end
+
+      sig { override.returns(T.nilable(HakumiComponents::Table::Configs::RowDrag)) }
+      def surface_row_drag
+        @row_drag
+      end
+
+      sig { override.returns(T::Boolean) }
+      def surface_column_drag?
+        @column_drag
+      end
+
+      sig { override.returns(PaginationValue) }
+      def surface_pagination
+        @pagination
+      end
+
+      sig { override.returns(T.nilable(String)) }
+      def surface_data_url
+        @data_url
+      end
+
+      sig { override.returns(TableContent) }
+      def surface_empty_text
+        @empty_text
+      end
+
+      sig { override.returns(TableContent) }
+      def surface_summary
+        @summary
+      end
+
+      sig { returns(T::Array[T::Array[HakumiComponents::Table::HeaderCell]]) }
+      def header_rows
+        @header_rows ||= build_header_rows(normalized_columns)
+      end
+
+      sig { override.returns(T::Array[DisplayRow]) }
+      def display_rows
+        @display_rows ||= HakumiComponents::Table::DisplayRows.build(
+          rows: @data_source,
+          pagination: @pagination
+        )
+      end
+
+      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
+
+      sig { params(row_key: RowSource).returns(T::Boolean) }
+      def row_selected?(row_key)
+        row_render_state.selected?(row_key)
+      end
+
+      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)
+        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)
+        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.nil?
+      end
+
+      sig { override.params(column: HakumiComponents::Table::ColumnDefinition).returns(T::Boolean) }
+      def column_filterable?(column)
+        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)
+      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
+
+      private
+
+      sig { void }
+      def validate_props!
+        validate_inclusion!(:size, SIZES)
+        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(string_or_numeric(value[:x] || value["x"])),
+          y: dimension_to_css(string_or_numeric(value[:y] || value["y"]))
+        }.compact.presence
+      end
+
+      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?
+
+        fallback
+      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
+
+        false
+      end
+
+      sig { override.returns(T::Array[ColumnInput]) }
+      def columns_data
+        return @columns_data if @columns_data && !@columns_data.empty?
+
+        slot_columns = respond_to?(:columns) ? public_send(:columns) : nil
+        return [] unless slot_columns.is_a?(Array) && slot_columns.any?
+
+        slot_columns.filter_map do |column|
+          column_hash = column.respond_to?(:to_h) ? column.to_h : nil
+          next unless column_hash.is_a?(Hash)
+
+          column_hash
+        end
+      end
+
+      sig { override.returns(HakumiComponents::Table::RowRenderState) }
+      def row_render_state
+        state = @row_render_state
+        return state unless state.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
+
+      sig { override.returns(Integer) }
+      def table_indent_size
+        @indent_size
+      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)
+
+        nil
+      end
+
+      public :columns_data
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Table
+    module Concerns
+      module AttributeHelpers
+        extend T::Sig
+
+        private
+
+        sig { params(attrs: Types::HtmlAttributes).returns(Types::DataAttributes) }
+        def existing_data_attributes(attrs)
+          data = attrs[:data]
+          return data if data.is_a?(Hash)
+
+          {}
+        end
+      end
+    end
+  end
+end