hakumi_components 0.1.18.pre → 0.1.19.pre

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

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

@@ -0,0 +1,277 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Table
+    module Concerns
+      module CellRendering
+        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 }
+        requires_ancestor { HakumiComponents::Table::Concerns::Ellipsis }
+
+        RowSource = T.type_alias { HakumiComponents::Table::RowRecord::Source }
+        DragHandleCellState = T.type_alias { { drag_handle: T::Boolean } }
+        SelectionCellState = T.type_alias { { type: Symbol, row_key: RowSource, checked: T::Boolean } }
+        ExpandCellState = T.type_alias { { row_key: RowSource, expanded: T::Boolean } }
+        CellState = T.type_alias { T.any(DragHandleCellState, SelectionCellState, ExpandCellState) }
+        CellContent = T.type_alias { T.any(CellState, RowSource, Types::ComponentRenderable) }
+        SpanAttributes = T.type_alias { T::Hash[Symbol, Types::HtmlPrimitive] }
+
+        sig do
+          params(
+            column: HakumiComponents::Table::ColumnDefinition,
+            row: HakumiComponents::Table::RowRecord,
+            row_index: Integer,
+            depth: Integer,
+            row_key: RowSource,
+            raw_value: RowSource
+          ).returns(Types::HtmlAttributes)
+        end
+        def cell_attributes(column, row, row_index, depth, row_key = nil, raw_value = nil)
+          attrs = T.let({
+            class: cell_classes(column),
+            data: {
+              column_key: column.key,
+              row_key: row_key,
+              sort_value: scalar_dom_value(extract_sort_value(column, row, raw_value)),
+              value: scalar_dom_value(raw_value)
+            }.compact
+          }, Types::HtmlAttributes)
+
+          attrs[:style] = "text-align: #{column.align};" if column.align
+          attrs[:style] = [ attrs[:style], "width: #{column.width};" ].compact.join(" ") if column.width
+          on_cell = column.on_cell
+          if on_cell
+            cell_attrs = on_cell.call(row.source, row_index)
+            if cell_attrs.is_a?(Hash)
+              attrs[:colspan] = cell_attrs[:colspan]
+              attrs[:rowspan] = cell_attrs[:rowspan]
+              attrs[:class] = [ attrs[:class], cell_attrs[:class] ].compact.join(" ")
+              attrs[:style] = [ attrs[:style], cell_attrs[:style] ].compact.join(" ")
+            end
+          end
+          if depth.positive? && column == cell_first_data_column
+            attrs[:style] = [ attrs[:style], "padding-left: #{depth * table_indent_size}px;" ].compact.join(" ")
+          end
+          apply_cell_editable_attributes!(attrs, column)
+          apply_cell_should_update_attributes!(attrs, column)
+          apply_cell_fixed_column_attributes!(attrs, column, header: false)
+          attrs
+        end
+
+        sig { params(column: HakumiComponents::Table::ColumnDefinition, col_span: Integer, row_span: Integer).returns(Types::HtmlAttributes) }
+        def header_cell_attributes(column, col_span:, row_span:)
+          attrs = T.let({
+            class: header_cell_classes(column),
+            data: header_cell_data_attributes(column)
+          }, Types::HtmlAttributes)
+          attrs[:colspan] = col_span if col_span > 1
+          attrs[:rowspan] = row_span if row_span > 1
+          attrs[:style] = "text-align: #{column.align};" if column.align
+          attrs[:style] = [ attrs[:style], "width: #{column.width};" ].compact.join(" ") if column.width
+          apply_cell_fixed_column_attributes!(attrs, column, header: true)
+          attrs
+        end
+
+        sig { params(column: HakumiComponents::Table::ColumnDefinition, row: HakumiComponents::Table::RowRecord, row_index: Integer, raw_value: RowSource).returns(CellContent) }
+        def cell_content(column, row, row_index, raw_value = nil)
+          return selection_cell(row, row_index) if column.selection?
+          return expand_cell(row, row_index) if column.expand?
+          return { drag_handle: true } if column.drag_handle?
+
+          value = raw_value
+          value = row.value(column.data_index) if value.nil? && column.data_index
+          renderer = column.render
+          rendered_value = renderer ? renderer.call(value, row.source, row_index) : value
+          rendered_value.is_a?(ViewComponent::Base) ? rendered_value : rendered_value
+        end
+
+        sig { params(column: HakumiComponents::Table::ColumnDefinition, content: CellContent, raw_value: RowSource, row: HakumiComponents::Table::RowRecord, row_index: Integer).returns(Types::RenderedContent) }
+        def render_cell_display(column, content, raw_value, row, row_index)
+          config = cell_ellipsis_config(column)
+
+          value_fragment = if content.is_a?(ViewComponent::Base)
+            T.unsafe(self).render(content)
+          else
+            content
+          end
+          value_fragment = raw_value if value_fragment.nil?
+
+          span_options = T.let({ class: "hakumi-table-cell-content" }, SpanAttributes)
+          title_text = cell_ellipsis_title(config, raw_value, value_fragment)
+          span_options[:title] = title_text if title_text.present?
+
+          display_value = if value_fragment.is_a?(String) || value_fragment.is_a?(ActiveSupport::SafeBuffer)
+            value_fragment
+          else
+            value_fragment.to_s
+          end
+          inner = T.unsafe(self).tag.span(**span_options) { display_value }
+
+          tooltip_component = cell_ellipsis_tooltip_component(config, raw_value, row.source, row_index)
+          tooltip_component ? T.unsafe(self).render(tooltip_component) { inner } : inner
+        end
+
+        sig { params(column: HakumiComponents::Table::ColumnDefinition).returns(String) }
+        def header_cell_classes(column)
+          classes = T.let([ "hakumi-table-cell", "hakumi-table-header-cell" ], T::Array[String])
+          classes.concat(responsive_classes(column))
+          classes << "hakumi-table-cell-ellipsis" if cell_ellipsis_config(column)
+          classes << "hakumi-table-cell-sortable" if column_sortable?(column)
+          classes << "hakumi-table-cell-filterable" if column_filterable?(column)
+          class_name = column.class_name
+          classes << class_name if class_name
+          classes.join(" ")
+        end
+
+        sig { params(column: HakumiComponents::Table::ColumnDefinition).returns(String) }
+        def cell_classes(column)
+          classes = T.let([ "hakumi-table-cell" ], T::Array[String])
+          classes.concat(responsive_classes(column))
+          classes << "hakumi-table-cell-ellipsis" if cell_ellipsis_config(column)
+          classes << "hakumi-table-cell-selection" if column.selection?
+          classes << "hakumi-table-cell-expand" if column.expand?
+          class_name = column.class_name
+          classes << class_name if class_name
+          classes.join(" ")
+        end
+
+        private
+
+        sig { abstract.returns(Integer) }
+        def table_indent_size; end
+
+        sig { abstract.returns(HakumiComponents::Table::RowRenderState) }
+        def row_render_state; end
+
+        sig { abstract.params(column: HakumiComponents::Table::ColumnDefinition).returns(T::Boolean) }
+        def column_sortable?(column); end
+
+        sig { abstract.params(column: HakumiComponents::Table::ColumnDefinition).returns(T::Boolean) }
+        def column_filterable?(column); end
+
+        sig { abstract.params(column: HakumiComponents::Table::ColumnDefinition).returns(T.nilable(Symbol)) }
+        def default_sort_order(column); end
+
+        sig { abstract.params(column: HakumiComponents::Table::ColumnDefinition).returns(HakumiComponents::Table::DefinitionTypes::ScalarList) }
+        def default_filtered_values(column); end
+
+        sig { returns(T.nilable(HakumiComponents::Table::ColumnDefinition)) }
+        def cell_first_data_column
+          T.unsafe(self).__send__(:first_data_column)
+        end
+
+        sig { params(attrs: Types::HtmlAttributes, column: HakumiComponents::Table::ColumnDefinition).void }
+        def apply_cell_editable_attributes!(attrs, column)
+          T.unsafe(self).__send__(:apply_editable_attributes!, attrs, column)
+        end
+
+        sig { params(attrs: Types::HtmlAttributes, column: HakumiComponents::Table::ColumnDefinition).void }
+        def apply_cell_should_update_attributes!(attrs, column)
+          T.unsafe(self).__send__(:apply_should_cell_update_attributes!, attrs, column)
+        end
+
+        sig { params(attrs: Types::HtmlAttributes, column: HakumiComponents::Table::ColumnDefinition, header: T::Boolean).void }
+        def apply_cell_fixed_column_attributes!(attrs, column, header:)
+          T.unsafe(self).__send__(:apply_fixed_column_attributes!, attrs, column, header: header)
+        end
+
+        sig { params(column: HakumiComponents::Table::ColumnDefinition).returns(T.nilable(HakumiComponents::Table::EllipsisConfig)) }
+        def cell_ellipsis_config(column)
+          T.unsafe(self).__send__(:ellipsis_config, column)
+        end
+
+        sig do
+          params(
+            config: T.nilable(HakumiComponents::Table::EllipsisConfig),
+            raw_value: RowSource,
+            content_fragment: T.untyped
+          ).returns(T.nilable(String))
+        end
+        def cell_ellipsis_title(config, raw_value, content_fragment)
+          T.unsafe(self).__send__(:ellipsis_title, config, raw_value, content_fragment)
+        end
+
+        sig do
+          params(
+            config: T.nilable(HakumiComponents::Table::EllipsisConfig),
+            raw_value: RowSource,
+            row: RowSource,
+            row_index: Integer
+          ).returns(T.nilable(HakumiComponents::Tooltip::Component))
+        end
+        def cell_ellipsis_tooltip_component(config, raw_value, row, row_index)
+          T.unsafe(self).__send__(:ellipsis_tooltip_component, config, raw_value, row, row_index)
+        end
+
+        sig { params(column: HakumiComponents::Table::ColumnDefinition).returns(T::Array[String]) }
+        def responsive_classes(column)
+          responsive = column.responsive
+          return [] unless responsive&.any?
+
+          responsive.map do |breakpoint|
+            "hakumi-table-col-show-#{breakpoint}"
+          end.prepend("hakumi-table-col-responsive")
+        end
+
+        sig { params(column: HakumiComponents::Table::ColumnDefinition).returns(Types::DataAttributes) }
+        def header_cell_data_attributes(column)
+          sortable = column_sortable?(column)
+          filterable = column_filterable?(column)
+          data_attrs = T.let({
+            column_key: column.key.to_s,
+            field: column.data_index.to_s,
+            sortable: sortable,
+            filterable: filterable,
+            default_sort: default_sort_order(column).to_s,
+            default_filter: default_filtered_values(column).to_json
+          }, Types::DataAttributes)
+
+          data_attrs[:sort_field] = column.sort_value.to_s if column.sort_value
+          data_attrs[:action] = "click->hakumi--table#toggleSort" if sortable
+          data_attrs["hakumi--table-target"] = "filterToggle" if filterable
+          data_attrs
+        end
+
+        sig { params(column: HakumiComponents::Table::ColumnDefinition, row: HakumiComponents::Table::RowRecord, raw_value: RowSource).returns(RowSource) }
+        def extract_sort_value(column, row, raw_value)
+          sort_value_config = column.sort_value
+          return raw_value unless sort_value_config
+
+          if sort_value_config.is_a?(Proc)
+            sort_value_config.call(raw_value, row.source)
+          elsif sort_value_config.is_a?(Symbol) || sort_value_config.is_a?(String)
+            row.value(sort_value_config.to_sym)
+          else
+            raw_value
+          end
+        end
+
+        sig { params(row: HakumiComponents::Table::RowRecord, row_index: Integer).returns(SelectionCellState) }
+        def selection_cell(row, row_index)
+          row_render_state.selection_cell(row, row_index)
+        end
+
+        sig { params(row: HakumiComponents::Table::RowRecord, row_index: Integer).returns(ExpandCellState) }
+        def expand_cell(row, row_index)
+          row_render_state.expand_cell(row, row_index)
+        end
+
+        sig { params(value: T.untyped).returns(T.nilable(Types::ValidationPrimitive)) }
+        def scalar_dom_value(value)
+          return value if value.is_a?(String) || value.is_a?(Numeric) || value == true || value == false
+
+          nil
+        end
+      end
+    end
+  end
+end