hakumi_components 0.1.17.pre → 0.1.19.pre

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