hakumi_components 0.1.18.pre → 0.1.19.pre

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

@@ -0,0 +1,143 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Table
+    class EllipsisConfig
+      extend T::Helpers
+      extend T::Sig
+      abstract!
+      sealed!
+
+      InputValue = T.type_alias { HakumiComponents::Table::DefinitionTypes::ConfigInputValue }
+      InputHash = T.type_alias { HakumiComponents::Table::DefinitionTypes::ConfigInputHash }
+
+      Input = T.type_alias do
+        T.nilable(T.any(
+          T::Boolean,
+          String,
+          InputHash
+        ))
+      end
+
+      class TooltipConfig
+        extend T::Sig
+
+        TooltipTitle = T.type_alias { T.nilable(T.any(String, Proc)) }
+
+        sig { params(title: TooltipTitle, options: InputHash).void }
+        def initialize(title:, options:)
+          @title = T.let(title, TooltipTitle)
+          @options = T.let(options, InputHash)
+        end
+
+        sig { returns(TooltipTitle) }
+        attr_reader :title
+
+        sig { returns(InputHash) }
+        attr_reader :options
+
+        sig { returns(InputHash) }
+        def to_h
+          @options.merge(title: @title).compact
+        end
+      end
+
+      # Ellipsis active, no tooltip. show_title controls the HTML title attribute.
+      class Simple < EllipsisConfig
+        extend T::Sig
+
+        sig { params(show_title: T::Boolean).void }
+        def initialize(show_title:)
+          @show_title = T.let(show_title, T::Boolean)
+        end
+
+        sig { override.returns(T::Boolean) }
+        attr_reader :show_title
+      end
+
+      # Ellipsis active with an Ant Design tooltip. tooltip is guaranteed non-nil.
+      # show_title controls whether the native HTML title attribute is also set.
+      class WithTooltip < EllipsisConfig
+        extend T::Sig
+
+        sig { params(show_title: T::Boolean, tooltip: TooltipConfig).void }
+        def initialize(show_title:, tooltip:)
+          @show_title = T.let(show_title, T::Boolean)
+          @tooltip = T.let(tooltip, TooltipConfig)
+        end
+
+        sig { override.returns(T::Boolean) }
+        attr_reader :show_title
+
+        sig { returns(TooltipConfig) }
+        attr_reader :tooltip
+      end
+
+      sig { abstract.returns(T::Boolean) }
+      def show_title; end
+
+      sig { params(input: Input).returns(T.nilable(EllipsisConfig)) }
+      def self.from_input(input)
+        return nil if input.nil? || input == false
+        return Simple.new(show_title: true) if input == true
+
+        if input.is_a?(Hash)
+          normalized = input.deep_symbolize_keys
+          tooltip = TooltipConfigBuilder.build(coerce_tooltip_input(normalized[:tooltip]))
+          show = normalized[:show_title] == true
+          return tooltip ? WithTooltip.new(show_title: show, tooltip: tooltip) : Simple.new(show_title: show)
+        end
+
+        # String input → tooltip whose title is the string itself
+        tooltip = TooltipConfigBuilder.build(input)
+        return nil unless tooltip
+
+        WithTooltip.new(show_title: false, tooltip: tooltip)
+      end
+
+      module TooltipConfigBuilder
+        extend T::Sig
+
+        sig { params(input: Input).returns(T.nilable(EllipsisConfig::TooltipConfig)) }
+        def self.build(input)
+          return nil if input.nil? || input == false
+          return EllipsisConfig::TooltipConfig.new(title: nil, options: {}) if input == true
+          return EllipsisConfig::TooltipConfig.new(title: input, options: {}) if input.is_a?(String)
+
+          return nil unless input.is_a?(Hash)
+
+          normalized = input.deep_symbolize_keys
+          title = normalized.delete(:title)
+          title = nil unless title.nil? || title.is_a?(String) || title.is_a?(Proc)
+          options = T.let({}, InputHash)
+          normalized.each do |key, value|
+            next unless key.is_a?(Symbol)
+
+            options[key] = value
+          end
+          EllipsisConfig::TooltipConfig.new(title: title, options: options)
+        end
+      end
+
+      class << self
+        extend T::Sig
+
+        private
+
+        sig { params(value: T.untyped).returns(Input) }
+        def coerce_tooltip_input(value)
+          return value if value.nil? || value == true || value == false || value.is_a?(String)
+          return nil unless value.is_a?(Hash)
+
+          value.each_with_object(T.let({}, InputHash)) do |(key, entry), result|
+            next unless key.is_a?(String) || key.is_a?(Symbol)
+            next unless entry.nil? || entry.is_a?(String) || entry.is_a?(Symbol) || entry.is_a?(Numeric) || entry == true || entry == false || entry.is_a?(Proc) || entry.is_a?(Array) || entry.is_a?(Hash)
+
+            result[key] = entry
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Table
+    class FixedOffset
+      extend T::Sig
+
+      SIDES = T.let(%i[left right].freeze, T::Array[Symbol])
+
+      sig { params(side: Symbol, offset: Float).void }
+      def initialize(side:, offset:)
+        raise ArgumentError, "Invalid fixed side: #{side.inspect}" unless SIDES.include?(side)
+
+        @side = T.let(side, Symbol)
+        @offset = T.let(offset, Float)
+      end
+
+      sig { returns(Symbol) }
+      attr_reader :side
+
+      sig { returns(Float) }
+      attr_reader :offset
+
+      sig { params(name: Symbol).returns(T.any(Symbol, Float)) }
+      def [](name)
+        case name
+        when :side then @side
+        when :offset then @offset
+        else
+          raise ArgumentError, "Unknown fixed offset key: #{name.inspect}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Table
+    class HeaderCell
+      extend T::Sig
+
+      sig { params(column: HakumiComponents::Table::ColumnDefinition, col_span: Integer, row_span: Integer).void }
+      def initialize(column:, col_span:, row_span:)
+        @column = T.let(column, HakumiComponents::Table::ColumnDefinition)
+        @col_span = T.let(col_span, Integer)
+        @row_span = T.let(row_span, Integer)
+      end
+
+      sig { returns(HakumiComponents::Table::ColumnDefinition) }
+      attr_reader :column
+
+      sig { returns(Integer) }
+      attr_reader :col_span, :row_span
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Table
+    class RowRecord
+      extend T::Sig
+
+      # T.untyped is intentional: table rows can be ActiveRecord models, plain
+      # Hashes, OpenStructs, or any PORO. RowRecord is the type-safe adapter
+      # that converts this external boundary into typed method calls.
+      Source = T.type_alias { T.untyped }
+      RowKeyConfig = T.type_alias { T.any(Types::StringOrSymbol, Proc) }
+
+      sig { params(source: Source, children_column_name: Types::StringOrSymbol).void }
+      def initialize(source:, children_column_name:)
+        @source = T.let(source, Source)
+        @children_column_name = T.let(children_column_name, Types::StringOrSymbol)
+      end
+
+      sig { returns(Source) }
+      attr_reader :source
+
+      sig { params(data_index: T.nilable(Types::StringOrSymbol)).returns(Source) }
+      def value(data_index)
+        return nil if data_index.nil?
+
+        if @source.is_a?(Hash)
+          return @source[data_index] if @source.key?(data_index)
+
+          string_key = data_index.to_s
+          return @source[string_key] if @source.key?(string_key)
+        end
+
+        return @source.public_send(data_index) if @source&.respond_to?(data_index)
+
+        nil
+      end
+
+      sig { params(row_key: RowKeyConfig, index: Integer).returns(Source) }
+      def key_for(row_key, index)
+        if row_key.is_a?(Proc)
+          row_key.arity == 1 ? row_key.call(@source) : row_key.call(@source, index)
+        else
+          value(row_key)
+        end
+      end
+
+      sig { returns(T::Array[HakumiComponents::Table::RowRecord]) }
+      def children
+        children_value = value(@children_column_name)
+        return [] unless children_value.is_a?(Array)
+
+        children_value.map do |child|
+          HakumiComponents::Table::RowRecord.new(source: child, children_column_name: @children_column_name)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,85 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Table
+    class RowRenderState
+      extend T::Sig
+
+      Row = T.type_alias { HakumiComponents::Table::RowRecord }
+      RowSource = T.type_alias { HakumiComponents::Table::RowRecord::Source }
+      RowKeyConfig = T.type_alias { HakumiComponents::Table::RowRecord::RowKeyConfig }
+      RowClassName = T.type_alias { T.nilable(T.any(String, Proc)) }
+      SelectionCellState = T.type_alias { { type: Symbol, row_key: RowSource, checked: T::Boolean } }
+      ExpandCellState = T.type_alias { { row_key: RowSource, expanded: T::Boolean } }
+
+      sig do
+        params(
+          row_key: RowKeyConfig,
+          row_selection: T.nilable(HakumiComponents::Table::Configs::RowSelection),
+          expandable: T.nilable(HakumiComponents::Table::Configs::Expandable),
+          row_class_name: RowClassName
+        ).void
+      end
+      def initialize(row_key:, row_selection:, expandable:, row_class_name:)
+        @row_key = T.let(row_key, RowKeyConfig)
+        @row_selection = T.let(row_selection, T.nilable(HakumiComponents::Table::Configs::RowSelection))
+        @expandable = T.let(expandable, T.nilable(HakumiComponents::Table::Configs::Expandable))
+        @row_class_name = T.let(row_class_name, RowClassName)
+      end
+
+      sig { params(row: Row, index: Integer).returns(RowSource) }
+      def row_key_for(row, index)
+        row.key_for(@row_key, index)
+      end
+
+      sig { params(row_key: RowSource).returns(T::Boolean) }
+      def selected?(row_key)
+        @row_selection&.selected_row_keys&.include?(row_key.to_s) == true
+      end
+
+      sig { params(row_key: RowSource).returns(T::Boolean) }
+      def expanded?(row_key)
+        return false unless row_key.is_a?(String) || row_key.is_a?(Symbol)
+
+        @expandable&.expanded_row?(row_key) == true
+      end
+
+      sig { params(row: Row, row_index: Integer, row_key: RowSource).returns(String) }
+      def row_classes(row, row_index, row_key)
+        classes = T.let([ "hakumi-table-row" ], T::Array[String])
+        classes << "hakumi-table-row-selected" if selected?(row_key)
+        classes << "hakumi-table-row-odd" if row_index.odd?
+
+        class_name = @row_class_name
+        if class_name.is_a?(Proc)
+          extra = class_name.call(row.source, row_index)
+          classes << extra if extra.is_a?(String)
+        elsif class_name.is_a?(String)
+          classes << class_name
+        end
+
+        classes.join(" ")
+      end
+
+      sig { params(row: Row, row_index: Integer).returns(SelectionCellState) }
+      def selection_cell(row, row_index)
+        row_key = row_key_for(row, row_index)
+        {
+          type: @row_selection&.type || :checkbox,
+          row_key: row_key,
+          checked: selected?(row_key)
+        }
+      end
+
+      sig { params(row: Row, row_index: Integer).returns(ExpandCellState) }
+      def expand_cell(row, row_index)
+        row_key = row_key_for(row, row_index)
+        {
+          row_key: row_key,
+          expanded: expanded?(row_key)
+        }
+      end
+    end
+  end
+end

data/app/components/hakumi_components/tabs/component.html.erb

@@ -1,6 +1,6 @@
 <%= tag.div(**wrapper_attributes) do %>
   <%= tag.div(class: "hakumi-tabs-nav", role: "tablist") do %>
-    <% if has_extra_content? && extra_content_left.present? %>
+    <% if extra_content? && extra_content_left.present? %>
       <%= tag.div(class: "hakumi-tabs-extra-content hakumi-tabs-extra-content-left") do %>
         <%= extra_content_left %>
       <% end %>
@@ -9,15 +9,15 @@
     <%= tag.div(class: "hakumi-tabs-nav-wrap", data: { "hakumi--tabs-target": "navWrap" }) do %>
       <%= tag.div(class: "hakumi-tabs-nav-list", style: nav_list_style, data: { "hakumi--tabs-target": "navList" }) do %>
         <% items.each_with_index do |item, index| %>
-          <% is_active = initial_active_key ? (item.key.to_s == initial_active_key.to_s) : (index == 0) %>
+          <% is_active = item_active?(item, index) %>
           <%= tag.div(**item.tab_attributes(is_active)) do %>
             <%= tag.div(class: "hakumi-tabs-tab-btn") do %>
-              <% if item.icon %>
+              <% if item.icon_component %>
                 <%= tag.span(class: "hakumi-tabs-tab-icon") do %>
-                  <%= render HakumiComponents::Icon::Component.new(name: item.icon) %>
+                  <%= render item.icon_component %>
                 <% end %>
               <% end %>
-              <%= tag.span(item.label || item.key, class: "hakumi-tabs-tab-label") %>
+              <%= tag.span(item.display_label, class: "hakumi-tabs-tab-label") %>
             <% end %>
             <% if item.closable %>
               <%= render HakumiComponents::Button::Component.new(
@@ -54,7 +54,7 @@
     <%= tag.div(class: "hakumi-tabs-nav-operations", style: "display: none;", data: { "hakumi--tabs-target": "operations" }) do %>
       <%= render HakumiComponents::Select::Component.new(
         name: "tabs_overflow_select",
-        options: items.map { |item| [item.label || item.key, item.key] },
+        options: items.map { |item| [item.public_send(:display_label).to_s, item.public_send(:key)] },
         variant: :borderless,
         trigger: :hover,
         standalone: true,
@@ -62,7 +62,7 @@
       ) %>
     <% end %>
 
-    <% if has_extra_content? && extra_content_right.present? %>
+    <% if extra_content? && extra_content_right.present? %>
       <%= tag.div(class: "hakumi-tabs-extra-content hakumi-tabs-extra-content-right") do %>
         <%= extra_content_right %>
       <% end %>
@@ -72,7 +72,7 @@
   <%= tag.div(class: "hakumi-tabs-content-holder") do %>
     <%= tag.div(class: ["hakumi-tabs-content", ("hakumi-tabs-content-animated" if animated)].compact.join(" ")) do %>
       <% items.each_with_index do |item, index| %>
-        <% is_active = initial_active_key ? (item.key.to_s == initial_active_key.to_s) : (index == 0) %>
+        <% is_active = item_active?(item, index) %>
         <%= tag.div(**item.pane_attributes(is_active)) do %>
           <% if item.force_render || is_active || !destroy_inactive_tab_pane %>
             <%= item.content %>