hakumi_components 0.1.18.pre → 0.1.19.pre

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

@@ -1,39 +1,72 @@
+# typed: strict
 # frozen_string_literal: true
 
 module HakumiComponents
   module Table
     module Concerns
-      # Column normalization and management for Table component
       module Columns
         extend ActiveSupport::Concern
+        extend T::Sig
+        extend T::Helpers
 
-        # Get all leaf columns (columns without children)
+        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
 
-        # Count of leaf columns (minimum 1)
+        sig { returns(Integer) }
         def leaf_column_count
           [ leaf_columns.size, 1 ].max
         end
 
-        # Check if table has selection column
+        sig { returns(T::Boolean) }
         def selection_column?
-          @row_selection.present?
+          !row_selection_config.nil?
         end
 
-        # Check if table has expandable rows
+        sig { returns(T::Boolean) }
         def expandable?
-          @expandable.present?
+          !expandable_config.nil?
         end
 
-        # Check if table has expand column
+        sig { returns(T::Boolean) }
         def expand_column?
-          expandable? && @expandable[:show_expand_column] != false
+          expandable_config&.show_expand_column == true
         end
 
-        # Get normalized columns with special columns inserted
+        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)
@@ -47,10 +80,9 @@ module HakumiComponents
 
         private
 
-        # Normalize an array of column definitions
+        sig { params(columns: T::Array[ColumnInput]).returns(T::Array[HakumiComponents::Table::ColumnDefinition]) }
         def normalize_columns(columns)
-          Array(columns).filter_map do |column|
-            column = column.public_send(:to_h) if column.respond_to?(:to_h)
+          columns.filter_map do |column|
             if column == HakumiComponents::Table::Component::SELECTION_COLUMN
               selection_column_definition
             elsif column == HakumiComponents::Table::Component::EXPAND_COLUMN
@@ -61,158 +93,328 @@ module HakumiComponents
           end
         end
 
-        # Normalize a single column definition
+        sig { params(column: ColumnInputHash).returns(T.nilable(HakumiComponents::Table::ColumnDefinition)) }
         def normalize_column(column)
           normalized = column.deep_symbolize_keys
-          return nil if normalized[:hidden]
-
-          normalized[:key] ||= normalized[:data_index] || generate_id("col")
-          normalized[:ellipsis] = normalize_ellipsis_option(normalized[:ellipsis])
-          normalized[:responsive] = normalize_responsive_breakpoints(normalized[:responsive])
-          normalized[:width] = dimension_to_css(normalized[:width])
-          normalized[:fixed] = normalized[:fixed]&.to_sym if normalized[:fixed]
-          normalized[:fixed] = nil unless HakumiComponents::Table::Component::FIXED_SIDES.include?(normalized[:fixed])
-          normalized[:editable] = normalize_column_editable(normalized[:editable])
-          normalized[:should_cell_update] = normalize_should_cell_update(normalized[:should_cell_update])
-          if normalized[:children]
-            normalized[:children] = normalize_columns(normalized[:children])
-          end
-          normalized
+          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
 
-        # Insert drag handle column if needed
+        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?)
 
-          if columns.any? { |col| col.is_a?(Hash) && col[:drag_handle] }
-            columns
-          else
-            [ drag_handle_column_definition, *columns ]
-          end
+          [ drag_handle_column_definition, *columns ]
         end
 
-        # Insert selection column if needed
+        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?)
 
-          if columns.any? { |col| col.is_a?(Hash) && col[:selection] }
-            columns
-          elsif columns.any? { |col| col == HakumiComponents::Table::Component::SELECTION_COLUMN }
-            columns.map { |col| col == HakumiComponents::Table::Component::SELECTION_COLUMN ? selection_column_definition : col }
-          else
-            [ selection_column_definition, *columns ]
-          end
+          [ selection_column_definition, *columns ]
         end
 
-        # Insert expand column if needed
+        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?)
 
-          if columns.any? { |col| col.is_a?(Hash) && col[:expand] }
-            columns
-          elsif columns.any? { |col| col == HakumiComponents::Table::Component::EXPAND_COLUMN }
-            columns.map { |col| col == HakumiComponents::Table::Component::EXPAND_COLUMN ? expand_column_definition : col }
-          else
-            [ expand_column_definition, *columns ]
-          end
+          [ expand_column_definition, *columns ]
         end
 
-        # Definition for selection column
+        sig { returns(HakumiComponents::Table::ColumnDefinition) }
         def selection_column_definition
-          {
+          HakumiComponents::Table::ColumnDefinition.new(
             key: "__selection__",
             title: "",
             selection: true,
             width: "48px",
             align: :center
-          }
+          )
         end
 
-        # Definition for expand column
+        sig { returns(HakumiComponents::Table::ColumnDefinition) }
         def expand_column_definition
-          {
+          HakumiComponents::Table::ColumnDefinition.new(
             key: "__expand__",
             title: "",
             expand: true,
             width: "48px",
             align: :center
-          }
+          )
         end
 
-        # Check if drag handle column should be added
+        sig { returns(T::Boolean) }
         def drag_handle_column?
-          @row_drag&.dig(:handle)
+          row_drag_config&.handle == true
         end
 
-        # Definition for drag handle column
+        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
 
-        # Get first data column (non-special column)
+        sig { returns(T.nilable(HakumiComponents::Table::ColumnDefinition)) }
         def first_data_column
-          @first_data_column ||= leaf_columns.find { |col| !col[:selection] && !col[:expand] }
+          @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
 
-        # Recursively flatten all leaf columns
+        sig { params(columns: T::Array[HakumiComponents::Table::ColumnDefinition]).returns(T::Array[HakumiComponents::Table::ColumnDefinition]) }
         def flatten_leaf_columns(columns)
           columns.flat_map do |column|
-            children = column[:children]
-            if children.is_a?(Array) && children.present?
-              flatten_leaf_columns(children)
-            else
-              [ column ]
-            end
+            column.children.empty? ? [ column ] : flatten_leaf_columns(column.children)
           end
         end
 
-        # Count leaf columns recursively
+        sig { params(columns: T::Array[HakumiComponents::Table::ColumnDefinition]).returns(Integer) }
         def leaf_count(columns)
-          columns.sum do |column|
-            children = column[:children]
-            children.is_a?(Array) && children.present? ? leaf_count(children) : 1
-          end
+          columns.sum { |column| column.children.empty? ? 1 : leaf_count(column.children) }
         end
 
-        # Calculate maximum depth of column hierarchy
+        sig { params(columns: T::Array[HakumiComponents::Table::ColumnDefinition], depth: Integer).returns(Integer) }
         def max_depth(columns, depth = 1)
           columns.map do |column|
-            children = column[:children]
-            if children.is_a?(Array) && children.present?
-              max_depth(children, depth + 1)
-            else
-              depth
-            end
+            column.children.empty? ? depth : max_depth(column.children, depth + 1)
           end.max || depth
         end
 
-        # Build header rows for rendering
+        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 = Array.new(depth) { [] }
+          rows = T.let(Array.new(depth) { [] }, T::Array[T::Array[HakumiComponents::Table::HeaderCell]])
           build_rows_recursive(columns, 0, rows, depth)
           rows
         end
 
-        # Recursively build header rows
+        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|
-            children = column[:children]
-            if children.is_a?(Array) && children.present?
-              col_span = leaf_count(children)
-              rows[level] << { column: column, col_span: col_span, row_span: 1 }
-              build_rows_recursive(children, level + 1, rows, max_depth)
+            if column.children.empty?
+              row << HakumiComponents::Table::HeaderCell.new(column: column, col_span: 1, row_span: max_depth - level)
             else
-              rows[level] << { column: column, col_span: 1, row_span: max_depth - level }
+              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

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

@@ -1,119 +1,66 @@
+# typed: strict
 # frozen_string_literal: true
 
 module HakumiComponents
   module Table
     module Concerns
-      # Editable cell and row functionality for Table component
       module Editable
         extend ActiveSupport::Concern
+        extend T::Sig
+        extend T::Helpers
 
-        EDITABLE_MODES = %i[cell row].freeze
-        EDITABLE_TRIGGERS = %i[click dblclick].freeze
-        EDITABLE_INPUT_TYPES = %i[text number textarea select].freeze
+        include AttributeHelpers
 
-        # Returns JSON configuration for the table-level editable settings
-        # to be passed to the Stimulus controller.
-        #
-        # @return [String, nil] JSON string or nil if not editable
-        def editable_config_json
-          return nil unless @editable
-
-          @editable.to_json
-        end
-
-        private
-
-        # Normalizes the table-level editable configuration.
-        # Accepts boolean, symbol (:cell or :row), or hash with options.
-        # Returns nil if editing is disabled, or a hash with normalized options.
-        #
-        # @param value [Boolean, Symbol, Hash, nil] editable configuration
-        # @return [Hash, nil] normalized configuration
-        def normalize_editable(value)
-          return nil if value.nil? || value == false
-
-          case value
-          when true
-            { mode: :cell, trigger: :click }
-          when Symbol
-            mode = EDITABLE_MODES.include?(value) ? value : :cell
-            { mode: mode, trigger: :click }
-          when Hash
-            normalized = value.deep_symbolize_keys
-            mode = normalized[:mode]&.to_sym
-            normalized[:mode] = EDITABLE_MODES.include?(mode) ? mode : :cell
-            trigger = normalized[:trigger]&.to_sym
-            normalized[:trigger] = EDITABLE_TRIGGERS.include?(trigger) ? trigger : :click
-            normalized
-          end
-        end
+        abstract!
 
-        # Normalizes column-level editable configuration.
-        # Column editable can override table-level settings.
-        #
-        # @param value [Boolean, Hash, nil] column editable configuration
-        # @return [Hash, nil] normalized configuration
-        def normalize_column_editable(value)
-          return nil if value.nil? || value == false
-          return {} if value == true
-          return nil unless value.is_a?(Hash)
+        sig { abstract.returns(T.nilable(HakumiComponents::Table::Configs::Editable)) }
+        def table_editable_config; end
 
-          normalized = value.deep_symbolize_keys
-          input_type = normalized[:type]&.to_sym || normalized[:input_type]&.to_sym
-          normalized[:input_type] = EDITABLE_INPUT_TYPES.include?(input_type) ? input_type : :text
-          normalized.except(:type)
+        sig { returns(T.nilable(String)) }
+        def editable_config_json
+          config = table_editable_config
+          config ? config.to_h.to_json : nil
         end
 
-        def normalize_should_cell_update(value)
-          case value
-          when Symbol
-            value.to_s
-          when String
-            value.strip.presence
-          end
-        end
+        private
 
-        # Applies editable attributes to cell
+        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(" ")
-          attrs[:data] ||= {}
-          attrs[:data][:editable] = true
-          attrs[:data][:editableConfig] = payload.to_json
-          attrs[:data][:action] = "click->hakumi--table#editCell"
+          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]
+          hook = column.should_cell_update
           return unless hook.present?
 
-          attrs[:data] ||= {}
-          attrs[:data][:should_cell_update] = hook
+          data_attrs = existing_data_attributes(attrs)
+          data_attrs[:should_cell_update] = hook
+          attrs[:data] = data_attrs
         end
 
-        # Returns the editable payload for a specific cell/column.
-        # Used to add data-editable-config attribute to editable cells.
-        #
-        # @param column [Hash] the column definition
-        # @return [Hash, nil] editable configuration for the cell
+        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]
-          return nil unless column[:data_index]
-
-          column_config = column[:editable]
-
-          # Column must explicitly opt-in to be editable
-          return nil if column_config.nil? || column_config == false
-
-          # Merge table-level and column-level config
-          base_config = @editable&.dup || {}
-          base_config.merge!(column_config) if column_config.is_a?(Hash)
-
-          base_config[:data_index] = column[:data_index]
-          base_config[:key] = column[:key]
-          base_config
+          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