hakumi_components 0.1.18.pre → 0.1.19.pre

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

@@ -1,57 +1,58 @@
+# typed: strict
 # frozen_string_literal: true
 
 module HakumiComponents
   module Table
     module Concerns
-      # Text ellipsis and tooltip handling for Table cells
       module Ellipsis
         extend ActiveSupport::Concern
+        extend T::Sig
 
         private
 
+        sig { params(column: HakumiComponents::Table::ColumnDefinition).returns(T.nilable(HakumiComponents::Table::EllipsisConfig)) }
         def ellipsis_config(column)
-          column[:ellipsis]
+          value = column.ellipsis
+          value.is_a?(HakumiComponents::Table::EllipsisConfig) ? value : nil
         end
 
+        sig { params(option: HakumiComponents::Table::EllipsisConfig::Input).returns(T.nilable(HakumiComponents::Table::EllipsisConfig)) }
         def normalize_ellipsis_option(option)
-          return nil if option.nil? || option == false
-
-          if option == true
-            { show_title: true }
-          elsif option.is_a?(Hash)
-            normalized = option.deep_symbolize_keys
-            normalized[:tooltip] = normalize_ellipsis_tooltip_option(normalized[:tooltip])
-            normalized.compact.presence
-          else
-            { tooltip: normalize_ellipsis_tooltip_option(option) }
-          end
+          HakumiComponents::Table::EllipsisConfig.from_input(option)
         end
 
-        def normalize_ellipsis_tooltip_option(option)
-          return nil if option.nil? || option == false
-          return {} if option == true
-          return { title: option } if option.is_a?(String)
-          return option.deep_symbolize_keys if option.is_a?(Hash)
-
-          nil
+        sig do
+          params(
+            config: T.nilable(HakumiComponents::Table::EllipsisConfig),
+            raw_value: HakumiComponents::Table::RowRecord::Source,
+            content_fragment: T.untyped
+          ).returns(T.nilable(String))
         end
-
         def ellipsis_title(config, raw_value, content_fragment)
-          return nil unless config&.dig(:show_title)
+          return nil unless config&.show_title
 
-          value = raw_value.presence || content_fragment
-          value = value.to_s if value.respond_to?(:to_s)
-          value.present? ? value : nil
+          value = raw_value.nil? ? content_fragment : raw_value
+          return nil if value.nil?
+
+          text = value.to_s
+          text.empty? ? nil : text
         end
 
+        sig do
+          params(
+            config: T.nilable(HakumiComponents::Table::EllipsisConfig),
+            raw_value: HakumiComponents::Table::RowRecord::Source,
+            row: HakumiComponents::Table::RowRecord::Source,
+            row_index: Integer
+          ).returns(T.nilable(HakumiComponents::Tooltip::Component))
+        end
         def ellipsis_tooltip_component(config, raw_value, row, row_index)
-          tooltip = config&.dig(:tooltip)
-          return nil unless tooltip
+          return nil unless config.is_a?(HakumiComponents::Table::EllipsisConfig::WithTooltip)
 
-          options = tooltip.deep_dup
-          title = options.delete(:title)
+          options = config.tooltip.options.deep_dup
+          title = config.tooltip.title
           title ||= raw_value
-          title = title.call(row, row_index) if title.respond_to?(:call)
+          title = title.call(row, row_index) if title.is_a?(Proc)
           title = title.to_s if title.respond_to?(:to_s)
           return nil if title.blank?
 

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

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

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

@@ -0,0 +1,365 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Table
+    module Concerns
+      module SurfaceRendering
+        extend ActiveSupport::Concern
+        extend T::Sig
+        extend T::Helpers
+
+        abstract!
+
+        requires_ancestor { HakumiComponents::BaseComponent }
+        requires_ancestor { HakumiComponents::Table::Concerns::Columns }
+        requires_ancestor { HakumiComponents::Table::Concerns::Editable }
+        requires_ancestor { HakumiComponents::Table::Concerns::FixedColumns }
+
+        TableDisplayRow = T.type_alias { { row: HakumiComponents::Table::RowRecord, depth: Integer } }
+        RowSource = T.type_alias { HakumiComponents::Table::RowRecord::Source }
+        ScrollValue = T.type_alias { T.nilable(String) }
+        TableContent = T.type_alias { T.nilable(T.any(Types::Renderable, Proc)) }
+        PaginationValue = T.type_alias { HakumiComponents::Table::Configs::Pagination::Value }
+
+        sig { abstract.returns(T::Array[TableDisplayRow]) }
+        def display_rows; end
+
+        sig { abstract.params(column: HakumiComponents::Table::ColumnDefinition).returns(T.nilable(Symbol)) }
+        def default_sort_order(column); end
+
+        sig { abstract.returns(Symbol) }
+        def surface_size; end
+
+        sig { abstract.returns(T::Boolean) }
+        def surface_bordered?; end
+
+        sig { abstract.returns(T::Boolean) }
+        def surface_sticky?; end
+
+        sig { abstract.returns(ScrollValue) }
+        def surface_scroll_x; end
+
+        sig { abstract.returns(ScrollValue) }
+        def surface_scroll_y; end
+
+        sig { abstract.returns(Types::HtmlAttributes) }
+        def surface_html_options; end
+
+        sig { abstract.returns(T.nilable(HakumiComponents::Table::Configs::RowSelection)) }
+        def surface_row_selection; end
+
+        sig { abstract.returns(T::Array[Symbol]) }
+        def surface_sort_directions; end
+
+        sig { abstract.returns(T::Boolean) }
+        def surface_filter_on_close?; end
+
+        sig { abstract.returns(Symbol) }
+        def surface_filter_mode; end
+
+        sig { abstract.returns(HakumiComponents::Table::DefinitionTypes::SearchValue) }
+        def surface_filter_search; end
+
+        sig { abstract.returns(T.nilable(HakumiComponents::Table::Configs::Editable)) }
+        def surface_editable; end
+
+        sig { abstract.returns(T.nilable(HakumiComponents::Table::Configs::RowDrag)) }
+        def surface_row_drag; end
+
+        sig { abstract.returns(T::Boolean) }
+        def surface_column_drag?; end
+
+        sig { abstract.returns(PaginationValue) }
+        def surface_pagination; end
+
+        sig { abstract.returns(T.nilable(String)) }
+        def surface_data_url; end
+
+        sig { abstract.returns(TableContent) }
+        def surface_empty_text; end
+
+        sig { abstract.returns(TableContent) }
+        def surface_summary; end
+
+        sig { returns(String) }
+        def table_classes
+          T.unsafe(self).class_names(
+            "table",
+            {
+              size: surface_size,
+              bordered: surface_bordered?,
+              empty: display_rows.empty?,
+              sticky: surface_sticky?,
+              scroll_x: surface_scroll_x.present?,
+              scroll_y: surface_scroll_y.present?,
+              fixed: T.unsafe(self).fixed_columns?
+            },
+            T.unsafe(self).html_classes(surface_html_options)
+          )
+        end
+
+        sig { returns(Types::HtmlAttributes) }
+        def table_container_attributes
+          attrs = T.let({
+            class: container_classes,
+            data: { "hakumi--table-target": "scrollContainer" }
+          }, Types::HtmlAttributes)
+          styles = scroll_styles
+          attrs[:style] = styles if styles.present?
+          attrs
+        end
+
+        sig { returns(Types::HtmlAttributes) }
+        def table_attributes
+          attrs = T.let({ class: "hakumi-table-table" }, Types::HtmlAttributes)
+          attrs[:style] = table_style if table_style.present?
+          attrs
+        end
+
+        sig { returns(String) }
+        def container_classes
+          T.unsafe(self).class_names(
+            "table-container",
+            {
+              scroll_x: surface_scroll_x.present?,
+              scroll_y: surface_scroll_y.present?
+            }
+          )
+        end
+
+        sig { returns(Types::HtmlAttributes) }
+        def wrapper_attributes
+          T.unsafe(self).merge_attributes({ class: table_classes, data: wrapper_data_attributes }, surface_html_options)
+        end
+
+        sig { returns(Types::Renderable) }
+        def empty_state
+          empty_text = surface_empty_text
+          if empty_text
+            return T.unsafe(self).render(empty_text) if empty_text.is_a?(ViewComponent::Base)
+            return T.unsafe(self).render(empty_text) if empty_text.is_a?(ViewComponent::Slot)
+            return empty_text.call if empty_text.is_a?(Proc)
+
+            empty_text
+          else
+            T.unsafe(self).render(HakumiComponents::Empty::Component.new)
+          end
+        end
+
+        sig { returns(T.nilable(ViewComponent::Base)) }
+        def pagination_component
+          pagination = surface_pagination
+          return nil unless pagination
+          return nil if surface_data_url
+          return pagination if pagination.is_a?(ViewComponent::Base)
+
+          pagination.build_component
+        end
+
+        sig { returns(T.nilable(HakumiComponents::Pagination::Component)) }
+        def ajax_pagination_component
+          pagination = surface_pagination
+          return nil unless surface_data_url && pagination.is_a?(HakumiComponents::Table::Configs::Pagination)
+
+          pagination.build_ajax_component
+        end
+
+        sig { returns(Types::RenderedContent) }
+        def summary_content
+          summary = surface_summary
+          return nil unless summary
+
+          if summary.is_a?(Proc)
+            rows = display_rows.map { |row_data| row_data[:row] }
+            summary.call(rows)
+          else
+            summary
+          end
+        end
+
+        sig { returns(String) }
+        def scroll_styles
+          styles = T.let([], T::Array[String])
+          scroll_x = surface_scroll_x
+          scroll_y = surface_scroll_y
+          styles << "overflow-x: auto" if scroll_x
+          if scroll_y
+            styles << "max-height: #{T.unsafe(self).__send__(:dimension_to_css, scroll_y)}"
+            styles << "overflow-y: auto"
+          end
+          styles.join("; ")
+        end
+
+        sig { returns(T.nilable(String)) }
+        def table_style
+          scroll_x = surface_scroll_x
+          return nil unless scroll_x
+
+          "min-width: #{T.unsafe(self).__send__(:dimension_to_css, scroll_x)}"
+        end
+
+        sig { returns(T::Boolean) }
+        def selection_actions?
+          surface_row_selection&.selections_enabled == true
+        end
+
+        sig { returns(T::Boolean) }
+        def selection_all_enabled?
+          surface_row_selection&.type == :checkbox
+        end
+
+        sig { params(column: HakumiComponents::Table::ColumnDefinition).returns(T::Array[HakumiComponents::Table::DefinitionTypes::DefinitionHash]) }
+        def header_filter_options(column)
+          Kernel.Array(column.filters)
+        end
+
+        sig { params(column: HakumiComponents::Table::ColumnDefinition).returns(T::Boolean) }
+        def column_filter_multiple?(column)
+          column.filter_multiple
+        end
+
+        sig { returns(T.nilable(T::Hash[Symbol, String])) }
+        def current_sort_state
+          sorted_column = T.unsafe(self).__send__(:leaf_columns).find { |column| default_sort_order(column).present? }
+          return nil unless sorted_column
+
+          field = sorted_column.key.to_s
+          order = default_sort_order(sorted_column)
+          return nil unless order
+
+          { field: field, order: order.to_s }
+        end
+
+        sig { returns(T::Hash[Symbol, T::Boolean]) }
+        def selection_header_state
+          total = display_rows.size
+          selected = surface_row_selection&.selected_row_keys&.size || 0
+          {
+            checked: total.positive? && selected == total,
+            indeterminate: selected.positive? && selected < total
+          }
+        end
+
+        sig { returns(String) }
+        def select_all_text
+          T.unsafe(self).t_default(:select_all, default: "Select all")
+        end
+
+        sig { returns(String) }
+        def invert_text
+          T.unsafe(self).t_default(:invert, default: "Invert")
+        end
+
+        sig { returns(String) }
+        def clear_text
+          T.unsafe(self).t_default(:clear, default: "Clear")
+        end
+
+        sig { returns(String) }
+        def search_placeholder_text
+          T.unsafe(self).t_default(:search_placeholder, default: "Search")
+        end
+
+        sig { returns(String) }
+        def reset_text
+          T.unsafe(self).t_default(:reset, default: "Reset")
+        end
+
+        private
+
+        sig { returns(Types::DataAttributes) }
+        def wrapper_data_attributes
+          data_attributes = T.let(base_wrapper_data_attributes, Types::DataAttributes)
+          apply_wrapper_editable_data_attributes!(data_attributes)
+          apply_wrapper_pagination_data_attributes!(data_attributes)
+          apply_wrapper_drag_data_attributes!(data_attributes)
+          apply_wrapper_ajax_data_attributes!(data_attributes)
+          data_attributes
+        end
+
+        sig { returns(Types::DataAttributes) }
+        def base_wrapper_data_attributes
+          row_selection = surface_row_selection
+          {
+            controller: "hakumi--table",
+            "hakumi--table-selection-type-value": row_selection&.type,
+            "hakumi--table-selected-row-keys-value": row_selection&.selected_row_keys&.to_json || [].to_json,
+            "hakumi--table-preserve-selected-row-keys-value": row_selection&.preserve_selected_row_keys || false,
+            "hakumi--table-sort-directions-value": surface_sort_directions.join(","),
+            "hakumi--table-filter-on-close-value": surface_filter_on_close?,
+            "hakumi--table-filter-mode-value": surface_filter_mode,
+            "hakumi--table-filter-search-value": surface_filter_search
+          }
+        end
+
+        sig { params(data_attributes: Types::DataAttributes).void }
+        def apply_wrapper_editable_data_attributes!(data_attributes)
+          editable = surface_editable
+          editable_json = editable&.to_h&.to_json
+          data_attributes["hakumi--table-editable-config-value"] = editable_json if editable_json
+        end
+
+        sig { params(data_attributes: Types::DataAttributes).void }
+        def apply_wrapper_pagination_data_attributes!(data_attributes)
+          pagination = surface_pagination
+          return unless pagination.is_a?(HakumiComponents::Table::Configs::Pagination)
+
+          if pagination.href
+            data_attributes["hakumi--table-href-value"] = pagination.href
+            data_attributes["hakumi--table-server-side-value"] = true
+            data_attributes["pagination-state"] = true
+            apply_wrapper_current_sort_data_attributes!(data_attributes)
+          end
+
+          data_attributes["hakumi--table-turbo-frame-value"] = pagination.turbo_frame if pagination.turbo_frame
+          data_attributes["hakumi--table-sort-field-param-value"] = pagination.sort_field_param if pagination.sort_field_param
+          data_attributes["hakumi--table-sort-order-param-value"] = pagination.sort_order_param if pagination.sort_order_param
+        end
+
+        sig { params(data_attributes: Types::DataAttributes).void }
+        def apply_wrapper_current_sort_data_attributes!(data_attributes)
+          current_sort = current_sort_state
+          return unless current_sort
+
+          data_attributes["sort-field"] = current_sort[:field]
+          data_attributes["sort-order"] = current_sort[:order]
+        end
+
+        sig { params(data_attributes: Types::DataAttributes).void }
+        def apply_wrapper_drag_data_attributes!(data_attributes)
+          row_drag = surface_row_drag
+          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
+          data_attributes["hakumi--table-column-drag-value"] = true if surface_column_drag?
+        end
+
+        sig { params(data_attributes: Types::DataAttributes).void }
+        def apply_wrapper_ajax_data_attributes!(data_attributes)
+          data_url = surface_data_url
+          pagination = surface_pagination
+          return unless 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?(HakumiComponents::Table::Configs::Pagination)
+            data_attributes["hakumi--table-page-size-value"] = pagination.page_size
+          end
+        end
+
+        sig { returns(String) }
+        def columns_config_json
+          T.unsafe(self).__send__(:leaf_columns).map do |column|
+            {
+              key: column.key,
+              dataIndex: column.data_index,
+              sorter: !column.sorter.nil?
+            }.compact
+          end.to_json
+        end
+      end
+    end
+  end
+end