hakumi_components 0.1.18.pre → 0.1.19.pre

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

@@ -3,7 +3,6 @@
     <li class="hakumi-pagination-total-text"><%= total_text %></li>
   <% end %>
 
-  <%# Previous button %>
   <li
     class="hakumi-pagination-prev<%= ' hakumi-pagination-disabled' if prev_disabled? || disabled %>"
     data-action="click->hakumi--pagination#prev"
@@ -18,7 +17,6 @@
   </li>
 
   <% if simple %>
-    <%# Simple mode: input / total %>
     <li class="hakumi-pagination-simple-pager">
       <input
         type="text"
@@ -32,17 +30,16 @@
       <span class="hakumi-pagination-simple-total"><%= total_pages %></span>
     </li>
   <% else %>
-    <%# Page items %>
     <% page_items.each do |item| %>
-      <% if item[:type] == :page %>
+      <% if item.page? %>
         <li
-          class="hakumi-pagination-item hakumi-pagination-item-<%= item[:number] %><%= ' hakumi-pagination-item-active' if item[:number] == current %>"
-          data-page="<%= item[:number] %>"
+          class="hakumi-pagination-item hakumi-pagination-item-<%= item.number %><%= ' hakumi-pagination-item-active' if item.number == current %>"
+          data-page="<%= item.number %>"
           data-action="click->hakumi--pagination#goToPage"
           data-hakumi--pagination-target="page">
-          <a rel="nofollow"><%= item[:number] %></a>
+          <a rel="nofollow"><%= item.number %></a>
         </li>
-      <% elsif item[:type] == :jump_prev %>
+      <% elsif item.jump_prev? %>
         <li
           class="hakumi-pagination-jump-prev hakumi-pagination-jump-prev-custom-icon"
           data-action="click->hakumi--pagination#jumpPrev"
@@ -54,7 +51,7 @@
             </span>
           </a>
         </li>
-      <% elsif item[:type] == :jump_next %>
+      <% elsif item.jump_next? %>
         <li
           class="hakumi-pagination-jump-next hakumi-pagination-jump-next-custom-icon"
           data-action="click->hakumi--pagination#jumpNext"
@@ -70,7 +67,6 @@
     <% end %>
   <% end %>
 
-  <%# Next button %>
   <li
     class="hakumi-pagination-next<%= ' hakumi-pagination-disabled' if next_disabled? || disabled %>"
     data-action="click->hakumi--pagination#next"
@@ -90,7 +86,7 @@
         <%= render HakumiComponents::Select::Component.new(
           options: page_size_options.map { |size| ["#{size} / page", size] },
           value: page_size,
-          size: :middle,
+          size: :default,
           disabled: disabled,
           standalone: true
         ) %>

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

@@ -1,12 +1,42 @@
+# typed: strict
 # frozen_string_literal: true
 
 module HakumiComponents
   module Pagination
     class Component < HakumiComponents::BaseComponent
+      extend T::Sig
+
       SIZES = %i[default small].freeze
       ALIGNS = %i[start center end].freeze
       DEFAULT_PAGE_SIZE_OPTIONS = [ 10, 20, 50, 100 ].freeze
-
+      ShowTotalProc = T.type_alias { T.proc.params(total: Integer, range: T::Array[Integer]).returns(String) }
+      ShowTotal = T.type_alias { T.nilable(T.any(T::Boolean, String, ShowTotalProc)) }
+
+      sig do
+        params(
+          total: Integer,
+          current: Integer,
+          page_size: Integer,
+          size: Symbol,
+          align: Symbol,
+          disabled: T::Boolean,
+          simple: T::Boolean,
+          show_size_changer: T.nilable(T::Boolean),
+          show_quick_jumper: T::Boolean,
+          show_total: ShowTotal,
+          page_size_options: T::Array[Integer],
+          hide_on_single_page: T::Boolean,
+          prev_text: T.nilable(String),
+          next_text: T.nilable(String),
+          href: T.nilable(String),
+          page_param: Symbol,
+          per_page_param: Symbol,
+          turbo_frame: T.nilable(String),
+          turbo_action: T.nilable(String),
+          preserve_params: T.nilable(String),
+          html_options: Types::HtmlAttributeValue
+        ).void
+      end
       def initialize(
         total:,
         current: 1,
@@ -30,40 +60,42 @@ module HakumiComponents
         preserve_params: nil,
         **html_options
       )
-        @total = total
-        @current = current
-        @page_size = page_size
-        @size = size
-        @align = align
-        @disabled = disabled
-        @simple = simple
-        @show_size_changer = show_size_changer
-        @show_quick_jumper = show_quick_jumper
-        @show_total = show_total
-        @page_size_options = page_size_options
-        @hide_on_single_page = hide_on_single_page
-        @prev_text = prev_text
-        @next_text = next_text
-        @href = href
-        @page_param = page_param
-        @per_page_param = per_page_param
-        @turbo_frame = turbo_frame
-        @turbo_action = turbo_action
-        @preserve_params = preserve_params
-        @html_options = html_options
+        @total = T.let(total, Integer)
+        @current = T.let(current, Integer)
+        @page_size = T.let(page_size, Integer)
+        @size = T.let(size, Symbol)
+        @align = T.let(align, Symbol)
+        @disabled = T.let(disabled, T::Boolean)
+        @simple = T.let(simple, T::Boolean)
+        @show_size_changer = T.let(show_size_changer, T.nilable(T::Boolean))
+        @show_quick_jumper = T.let(show_quick_jumper, T::Boolean)
+        @show_total = T.let(show_total, ShowTotal)
+        @page_size_options = T.let(page_size_options, T::Array[Integer])
+        @hide_on_single_page = T.let(hide_on_single_page, T::Boolean)
+        @prev_text = T.let(prev_text, T.nilable(String))
+        @next_text = T.let(next_text, T.nilable(String))
+        @href = T.let(href, T.nilable(String))
+        @page_param = T.let(page_param, Symbol)
+        @per_page_param = T.let(per_page_param, Symbol)
+        @turbo_frame = T.let(turbo_frame, T.nilable(String))
+        @turbo_action = T.let(turbo_action, T.nilable(String))
+        @preserve_params = T.let(preserve_params, T.nilable(String))
+        @html_options = T.let(html_options, Types::HtmlAttributes)
 
         validate_props!
       end
 
+      sig { returns(T::Boolean) }
       def render?
-        return false if @hide_on_single_page && total_pages <= 1
-        true
+        !(@hide_on_single_page && total_pages <= 1)
       end
 
+      sig { returns(Integer) }
       def total_pages
         (@total.to_f / @page_size).ceil
       end
 
+      sig { returns(String) }
       def pagination_classes
         classes = [ "hakumi-pagination" ]
         classes << "hakumi-pagination-mini" if @size == :small
@@ -73,129 +105,130 @@ module HakumiComponents
         classes.join(" ")
       end
 
-      def stimulus_controller
-        "hakumi--pagination"
-      end
-
-      def stimulus_values
-        values = {
+      sig { returns(Types::HtmlAttributes) }
+      def wrapper_attributes
+        values = T.let({
           current: @current,
           page_size: @page_size,
           total: @total,
           disabled: @disabled,
           simple: @simple
-        }
+        }, Types::StimulusValues)
         values[:href] = @href if @href.present?
         values[:page_param] = @page_param.to_s if @href.present?
         values[:per_page_param] = @per_page_param.to_s if @href.present?
         values[:turbo_frame] = @turbo_frame if @turbo_frame.present?
         values[:turbo_action] = @turbo_action if @turbo_action.present?
         values[:preserve_params] = @preserve_params if @preserve_params.present?
-        values
-      end
 
-      def wrapper_attributes
-        base_attrs = {
-          class: pagination_classes,
-          data: {
-            controller: stimulus_controller
-          }.merge(stimulus_data_attributes)
-        }
-        merge_attributes(base_attrs, @html_options)
-      end
-
-      def stimulus_data_attributes
-        stimulus_values.transform_keys { |k| "#{stimulus_controller}-#{k.to_s.dasherize}-value" }
+        merge_attributes(
+          { class: pagination_classes, data: stimulus_attrs("hakumi--pagination", values) },
+          @html_options
+        )
       end
 
+      sig { returns(T::Boolean) }
       def prev_disabled?
         @current <= 1
       end
 
+      sig { returns(T::Boolean) }
       def next_disabled?
         @current >= total_pages
       end
 
+      sig { returns(T::Boolean) }
       def show_size_changer?
         return @show_size_changer unless @show_size_changer.nil?
+
         @total > 50
       end
 
+      sig { returns(T::Array[HakumiComponents::Pagination::PageItem]) }
       def page_items
         return [] if @simple
 
-        items = []
+        items = T.let([], T::Array[HakumiComponents::Pagination::PageItem])
         total = total_pages
         current = @current
 
-        # Always show first page
-        items << { type: :page, number: 1 }
+        items << HakumiComponents::Pagination::PageItem.new(kind: :page, number: 1)
 
         if total <= 7
-          # Show all pages
-          (2..total).each { |n| items << { type: :page, number: n } }
+          (2..total).each { |n| items << HakumiComponents::Pagination::PageItem.new(kind: :page, number: n) }
+        elsif current <= 4
+          (2..5).each { |n| items << HakumiComponents::Pagination::PageItem.new(kind: :page, number: n) }
+          items << HakumiComponents::Pagination::PageItem.new(kind: :jump_next)
+          items << HakumiComponents::Pagination::PageItem.new(kind: :page, number: total)
+        elsif current >= total - 3
+          items << HakumiComponents::Pagination::PageItem.new(kind: :jump_prev)
+          ((total - 4)..total).each { |n| items << HakumiComponents::Pagination::PageItem.new(kind: :page, number: n) }
         else
-          # Complex pagination with ellipsis
-          if current <= 4
-            # Near start
-            (2..5).each { |n| items << { type: :page, number: n } }
-            items << { type: :jump_next }
-            items << { type: :page, number: total }
-          elsif current >= total - 3
-            # Near end
-            items << { type: :jump_prev }
-            ((total - 4)..total).each { |n| items << { type: :page, number: n } }
-          else
-            # In the middle
-            items << { type: :jump_prev }
-            ((current - 1)..(current + 1)).each { |n| items << { type: :page, number: n } }
-            items << { type: :jump_next }
-            items << { type: :page, number: total }
-          end
+          items << HakumiComponents::Pagination::PageItem.new(kind: :jump_prev)
+          ((current - 1)..(current + 1)).each { |n| items << HakumiComponents::Pagination::PageItem.new(kind: :page, number: n) }
+          items << HakumiComponents::Pagination::PageItem.new(kind: :jump_next)
+          items << HakumiComponents::Pagination::PageItem.new(kind: :page, number: total)
         end
 
         items
       end
 
+      sig { returns(HakumiComponents::Icon::Component) }
       def prev_icon
         HakumiComponents::Icon::Component.new(name: :left)
       end
 
+      sig { returns(HakumiComponents::Icon::Component) }
       def next_icon
         HakumiComponents::Icon::Component.new(name: :right)
       end
 
+      sig { returns(HakumiComponents::Icon::Component) }
       def jump_prev_icon
         HakumiComponents::Icon::Component.new(name: :double_left)
       end
 
+      sig { returns(HakumiComponents::Icon::Component) }
       def jump_next_icon
         HakumiComponents::Icon::Component.new(name: :double_right)
       end
 
+      sig { returns(HakumiComponents::Icon::Component) }
       def ellipsis_icon
         HakumiComponents::Icon::Component.new(name: :ellipsis)
       end
 
+      sig { returns(T.nilable(String)) }
       def total_text
         return nil unless @show_total
 
         case @show_total
         when true
-          "Total #{@total} items"
+          t_default(:total, default: "Total %{count} items", count: @total)
         when String
           @show_total
         when Proc
-          @show_total.call(@total, [ (@current - 1) * @page_size + 1, @current * @page_size ].map { |n| [ n, @total ].min })
+          start_item = (@current - 1) * @page_size + 1
+          end_item = [ @current * @page_size, @total ].min
+          @show_total.call(@total, [ start_item, end_item ])
         end
       end
 
-      attr_reader :current, :page_size, :total, :disabled, :simple,
-                  :show_quick_jumper, :page_size_options, :prev_text, :next_text,
-                  :href, :page_param, :per_page_param, :turbo_frame, :turbo_action
+      sig { returns(Integer) }
+      attr_reader :current, :page_size, :total
+
+      sig { returns(T::Boolean) }
+      attr_reader :disabled, :simple, :show_quick_jumper
+
+      sig { returns(T::Array[Integer]) }
+      attr_reader :page_size_options
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :prev_text, :next_text, :href, :turbo_frame, :turbo_action
 
       private
 
+      sig { void }
       def validate_props!
         validate_inclusion!(:size, SIZES)
         validate_inclusion!(:align, ALIGNS)

data/app/components/hakumi_components/pagination/page_item.rb

@@ -0,0 +1,49 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Pagination
+    class PageItem
+      extend T::Sig
+
+      KINDS = T.let(%i[page jump_prev jump_next].freeze, T::Array[Symbol])
+
+      sig { params(kind: Symbol, number: T.nilable(Integer)).void }
+      def initialize(kind:, number: nil)
+        @kind = T.let(kind, Symbol)
+        @number = T.let(number, T.nilable(Integer))
+        validate_kind!
+      end
+
+      sig { returns(Symbol) }
+      attr_reader :kind
+
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :number
+
+      sig { returns(T::Boolean) }
+      def page?
+        @kind == :page
+      end
+
+      sig { returns(T::Boolean) }
+      def jump_prev?
+        @kind == :jump_prev
+      end
+
+      sig { returns(T::Boolean) }
+      def jump_next?
+        @kind == :jump_next
+      end
+
+      private
+
+      sig { void }
+      def validate_kind!
+        return if KINDS.include?(@kind)
+
+        raise ArgumentError, "Invalid page item kind: #{@kind.inspect}"
+      end
+    end
+  end
+end

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

@@ -1,69 +1,117 @@
+# typed: strict
 # frozen_string_literal: true
 
 module HakumiComponents
   module Popconfirm
     class Component < HakumiComponents::BaseComponent
-      PLACEMENTS = %w[
+      extend T::Sig
+
+      Placement = T.type_alias { T.any(Symbol, String) }
+      Trigger = T.type_alias { T.any(Symbol, String) }
+      ButtonType = T.type_alias { T.any(Symbol, String) }
+
+      PLACEMENTS = T.let(%i[
         top topLeft topRight
         bottom bottomLeft bottomRight
         left leftTop leftBottom
         right rightTop rightBottom
         auto
-      ].freeze
+      ].freeze, T::Array[Symbol])
 
-      TRIGGERS = %w[click hover focus].freeze
+      TRIGGERS = T.let(%i[click hover focus].freeze, T::Array[Symbol])
 
-      # Slots for content
       renders_one :icon
       renders_one :title
       renders_one :description
       renders_one :buttons
 
+      sig do
+        params(
+          params: T.any(ActionController::Parameters, HakumiComponents::Types::HtmlAttributes)
+        ).returns(HakumiComponents::Types::HtmlAttributes)
+      end
+      def self.extract_controller_locals(params)
+        {
+          placement: symbol_html_param(html_param(params, :placement)),
+          trigger: symbol_html_param(html_param(params, :trigger)),
+          disabled: boolean_html_param(html_param(params, :disabled)),
+          ok_type: symbol_html_param(html_param(params, :ok_type)),
+          show_cancel: boolean_html_param(html_param(params, :show_cancel) || true),
+          auto_adjust_overflow: boolean_html_param(html_param(params, :auto_adjust_overflow) || true)
+        }.compact
+      end
+
+      sig do
+        params(
+          placement: Placement,
+          trigger: Trigger,
+          disabled: T::Boolean,
+          ok_type: ButtonType,
+          show_cancel: T::Boolean,
+          auto_adjust_overflow: T::Boolean,
+          html_options: HakumiComponents::Types::HtmlAttributeValue
+        ).void
+      end
       def initialize(
-        placement: "top",
-        trigger: "click",
+        placement: :top,
+        trigger: :click,
         disabled: false,
         ok_type: :primary,
         show_cancel: true,
         auto_adjust_overflow: true,
         **html_options
       )
-        @placement = placement
-        @trigger = trigger
-        @disabled = disabled
-        @ok_type = ok_type
-        @show_cancel = show_cancel
-        @auto_adjust_overflow = auto_adjust_overflow
-        @html_options = html_options
+        @placement = T.let(placement.to_sym, Symbol)
+        @trigger = T.let(trigger.to_sym, Symbol)
+        @disabled = T.let(disabled, T::Boolean)
+        @ok_type = T.let(ok_type.to_sym, Symbol)
+        @show_cancel = T.let(show_cancel, T::Boolean)
+        @auto_adjust_overflow = T.let(auto_adjust_overflow, T::Boolean)
+        @html_options = T.let(html_options, HakumiComponents::Types::HtmlAttributes)
 
         validate_props!
       end
 
+      sig { returns(String) }
       def wrapper_classes
-        classes = [ "hakumi-popconfirm-wrapper" ]
-        classes << "hakumi-popconfirm-disabled" if @disabled
-        classes << @html_options[:class] if @html_options[:class]
-        classes.join(" ")
+        extras = T.let([], T::Array[T.nilable(String)])
+        extras << "hakumi-popconfirm-disabled" if @disabled
+        extras.concat(Array(html_classes(@html_options)).compact)
+
+        class_names(
+          "popconfirm-wrapper",
+          {},
+          extras
+        )
       end
 
+      sig { returns(HakumiComponents::Types::DataAttributes) }
       def data_attributes
-        {
+        data = T.let({
           controller: "hakumi--popconfirm",
           hakumi__popconfirm_placement_value: @placement,
           hakumi__popconfirm_trigger_value: @trigger,
           hakumi__popconfirm_disabled_value: @disabled,
           hakumi__popconfirm_show_cancel_value: @show_cancel,
           hakumi__popconfirm_auto_adjust_overflow_value: @auto_adjust_overflow
-        }
+        }, HakumiComponents::Types::DataAttributes)
+
+        existing = @html_options[:data]
+        return data unless existing.is_a?(Hash)
+
+        existing.each { |key, value| data[key] = value }
+        data
       end
 
       private
 
+      sig { void }
       def validate_props!
         validate_inclusion!(:placement, PLACEMENTS)
         validate_inclusion!(:trigger, TRIGGERS)
       end
 
+      sig { returns(ActiveSupport::SafeBuffer) }
       def default_icon_element
         render HakumiComponents::Icon::Component.new(name: "exclamation-circle", theme: :filled)
       end

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

@@ -13,10 +13,10 @@
         <div class="hakumi-popover-arrow" data-hakumi--popover-target="arrow"></div>
       <% end %>
       <div class="hakumi-popover-inner" role="presentation">
-        <% if has_title? %>
+        <% if title_present? %>
           <div class="hakumi-popover-title"><%= render_title %></div>
         <% end %>
-        <% if has_popover_content? %>
+        <% if popover_content? %>
           <div class="hakumi-popover-inner-content"><%= render_popover_content %></div>
         <% end %>
       </div>