hakumi_components 0.1.17.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 → 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,18 +9,18 @@
     <%= 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 Hakumi::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 Hakumi::Button::Component.new(
+              <%= render HakumiComponents::Button::Component.new(
                 type: :text,
                 size: :small,
                 icon: item.render_close_icon,
@@ -41,7 +41,7 @@
               <% if add_icon %>
                 <%= add_icon %>
               <% else %>
-                <%= render Hakumi::Icon::Component.new(name: :plus) %>
+                <%= render HakumiComponents::Icon::Component.new(name: :plus) %>
               <% end %>
             </div>
           <% end %>
@@ -52,9 +52,9 @@
     <% end %>
 
     <%= tag.div(class: "hakumi-tabs-nav-operations", style: "display: none;", data: { "hakumi--tabs-target": "operations" }) do %>
-      <%= render Hakumi::Select::Component.new(
+      <%= 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 %>

data/app/components/hakumi_components/tabs/component.rb

@@ -0,0 +1,246 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Tabs
+    class Component < HakumiComponents::BaseComponent
+      extend T::Sig
+
+      TabKey = T.type_alias { T.nilable(Types::HtmlKey) }
+      TabItem = T.type_alias { T.any(HakumiComponents::Tabs::Item::Component, ViewComponent::Slot) }
+
+      TYPES = %i[line card editable_card].freeze
+      TAB_POSITIONS = %i[top bottom left right].freeze
+      INDICATOR_ALIGNS = %i[start center end].freeze
+
+      renders_many :items, ->(
+        key:,
+        label: nil,
+        icon: nil,
+        disabled: false,
+        closable: nil,
+        close_icon: nil,
+        force_render: false,
+        &block
+      ) do
+        T.bind(self, HakumiComponents::Tabs::Component)
+        item = HakumiComponents::Tabs::Item::Component.new(
+          key: key,
+          label: label,
+          icon: icon,
+          disabled: disabled,
+          closable: closable.nil? ? (type == :editable_card) : closable,
+          close_icon: close_icon,
+          force_render: force_render,
+          parent: self
+        )
+        item.content = capture(&block) if block
+        item
+      end
+
+      sig do
+        params(
+          active_key: TabKey,
+          default_active_key: TabKey,
+          type: Symbol,
+          size: Symbol,
+          tab_position: Symbol,
+          centered: T::Boolean,
+          animated: T::Boolean,
+          indicator: T.nilable(Types::HtmlAttributes),
+          tab_bar_gutter: T.nilable(Integer),
+          tab_bar_extra_content_left: T.nilable(Types::Renderable),
+          tab_bar_extra_content_right: T.nilable(Types::Renderable),
+          add_icon: T.nilable(Types::Renderable),
+          hide_add: T::Boolean,
+          destroy_inactive_tab_pane: T::Boolean,
+          html_options: Types::HtmlAttributeValue
+        ).void
+      end
+      def initialize(
+        active_key: nil,
+        default_active_key: nil,
+        type: :line,
+        size: :default,
+        tab_position: :top,
+        centered: false,
+        animated: true,
+        indicator: nil,
+        tab_bar_gutter: nil,
+        tab_bar_extra_content_left: nil,
+        tab_bar_extra_content_right: nil,
+        add_icon: nil,
+        hide_add: false,
+        destroy_inactive_tab_pane: false,
+        **html_options
+      )
+        @active_key = T.let(active_key, TabKey)
+        @default_active_key = T.let(default_active_key, TabKey)
+        @type = T.let(type, Symbol)
+        @size = T.let(size, Symbol)
+        @tab_position = T.let(tab_position, Symbol)
+        @centered = T.let(centered, T::Boolean)
+        @animated = T.let(animated, T::Boolean)
+        @indicator = T.let(HakumiComponents::Tabs::IndicatorConfig.coerce(indicator), HakumiComponents::Tabs::IndicatorConfig)
+        @tab_bar_gutter = T.let(tab_bar_gutter, T.nilable(Integer))
+        @tab_bar_extra_content_left = T.let(tab_bar_extra_content_left, T.nilable(Types::Renderable))
+        @tab_bar_extra_content_right = T.let(tab_bar_extra_content_right, T.nilable(Types::Renderable))
+        @add_icon = T.let(add_icon, T.nilable(Types::Renderable))
+        @hide_add = T.let(hide_add, T::Boolean)
+        @destroy_inactive_tab_pane = T.let(destroy_inactive_tab_pane, T::Boolean)
+        @html_options = T.let(html_options, Types::HtmlAttributes)
+        @close_button_template_html = T.let(nil, T.nilable(String))
+
+        validate_props!
+      end
+
+      sig { returns(Symbol) }
+      attr_reader :type, :size, :tab_position
+
+      sig { returns(T::Boolean) }
+      attr_reader :centered, :animated, :hide_add, :destroy_inactive_tab_pane
+
+      sig { returns(HakumiComponents::Tabs::IndicatorConfig) }
+      attr_reader :indicator
+
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :tab_bar_gutter
+
+      sig { returns(T.nilable(Types::Renderable)) }
+      attr_reader :tab_bar_extra_content_left, :tab_bar_extra_content_right, :add_icon
+
+      sig { returns(TabKey) }
+      attr_reader :active_key, :default_active_key
+
+      sig { returns(String) }
+      def tabs_classes
+        class_names(
+          "tabs",
+          {
+            @type => @type != :line,
+            @size => @size != :default,
+            @tab_position => @tab_position != :top,
+            centered: @centered
+          },
+          html_classes(@html_options)
+        )
+      end
+
+      sig { returns(T::Boolean) }
+      def vertical?
+        %i[left right].include?(@tab_position)
+      end
+
+      sig { returns(T::Boolean) }
+      def editable?
+        @type == :editable_card
+      end
+
+      sig { returns(TabKey) }
+      def initial_active_key
+        @active_key || @default_active_key
+      end
+
+      sig { returns(T.nilable(Numeric)) }
+      def indicator_size
+        @indicator.size
+      end
+
+      sig { returns(Symbol) }
+      def indicator_align
+        @indicator.align
+      end
+
+      sig { returns(Types::HtmlAttributes) }
+      def wrapper_attributes
+        values = T.let({
+          active_key: initial_active_key,
+          tab_position: @tab_position.to_s,
+          indicator_align: indicator_align.to_s
+        }, Types::StimulusValues)
+        values[:indicator_size] = indicator_size if indicator_size
+        if editable?
+          values[:tab_template] = tab_template_html
+          values[:pane_template] = pane_template_html
+          values[:close_button_template] = close_button_template_html
+        end
+
+        merge_attributes(
+          { class: tabs_classes, data: stimulus_attrs("hakumi--tabs", values) },
+          @html_options.except(:class)
+        )
+      end
+
+      sig { returns(String) }
+      def tab_template_html
+        '<div class="hakumi-tabs-tab" data-key="{{key}}" data-hakumi--tabs-target="tab" data-action="click->hakumi--tabs#selectTab"><div class="hakumi-tabs-tab-btn"><span class="hakumi-tabs-tab-label">{{label}}</span></div>{{closeButton}}</div>'.dup.force_encoding("UTF-8")
+      end
+
+      sig { returns(String) }
+      def pane_template_html
+        '<div class="hakumi-tabs-tabpane hakumi-tabs-tabpane-hidden" data-key="{{key}}" data-hakumi--tabs-target="pane" aria-hidden="true">{{content}}</div>'.dup.force_encoding("UTF-8")
+      end
+
+      sig { returns(String) }
+      def close_button_template_html
+        @close_button_template_html ||= ::ApplicationController.render(
+          HakumiComponents::Button::Component.new(
+            type: :text,
+            size: :small,
+            icon: :close,
+            class: "hakumi-tabs-tab-remove",
+            aria: { label: remove_tab_aria_label },
+            data: { action: "click->hakumi--tabs#removeTab", key: "{{key}}" }
+          ),
+          layout: false
+        ).strip
+      end
+
+      sig { returns(String) }
+      def remove_tab_aria_label
+        t_default(:remove_tab_aria_label, default: "Remove tab")
+      end
+
+      sig { returns(T.nilable(String)) }
+      def nav_list_style
+        styles = T.let([], T::Array[String])
+        styles << "--tab-bar-gutter: #{@tab_bar_gutter}px" if @tab_bar_gutter
+        styles.join("; ") if styles.any?
+      end
+
+      sig { returns(T::Boolean) }
+      def extra_content?
+        @tab_bar_extra_content_left.present? || @tab_bar_extra_content_right.present?
+      end
+
+      sig { returns(T.nilable(Types::Renderable)) }
+      def extra_content_left
+        @tab_bar_extra_content_left
+      end
+
+      sig { returns(T.nilable(Types::Renderable)) }
+      def extra_content_right
+        @tab_bar_extra_content_right
+      end
+
+      sig { params(item: TabItem, index: Integer).returns(T::Boolean) }
+      def item_active?(item, index)
+        key = item.public_send(:key)
+        active = initial_active_key
+        active ? key.to_s == active.to_s : index == 0
+      end
+
+      private
+
+      sig { void }
+      def validate_props!
+        validate_inclusion!(:type, TYPES)
+        validate_inclusion!(:size, SIZES)
+        validate_inclusion!(:tab_position, TAB_POSITIONS)
+        return if INDICATOR_ALIGNS.include?(@indicator.align)
+
+        raise ArgumentError, "Invalid indicator align: #{@indicator.align}. Must be one of: #{INDICATOR_ALIGNS.join(', ')}"
+      end
+    end
+  end
+end