hakumi_components 0.1.18.pre → 0.1.19.pre

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

@@ -1,37 +1,47 @@
+# typed: strict
 # frozen_string_literal: true
 
 module HakumiComponents
   module AdminPanel
     class Component < HakumiComponents::BaseComponent
+      extend T::Sig
+
+      sig do
+        params(params: T.any(ActionController::Parameters, Types::HtmlAttributes)).returns(T::Hash[Symbol, T.any(String, T::Boolean)])
+      end
       def self.extract_controller_locals(params)
         {
-          title: params[:title],
-          enabled: params[:enabled] != "false"
+          title: string_html_param(html_param(params, :title)) || "Admin Panel",
+          enabled: boolean_html_param(html_param(params, :enabled)) != false
         }.compact
       end
 
+      sig { params(title: String, enabled: T::Boolean, html_options: Types::HtmlAttributeValue).void }
       def initialize(title: "Admin Panel", enabled: true, **html_options)
-        @title = title
-        @enabled = enabled
-        @html_options = html_options
+        @title = T.let(title, String)
+        @enabled = T.let(enabled, T::Boolean)
+        @html_options = T.let(html_options, Types::HtmlAttributes)
       end
 
+      sig { returns(T::Boolean) }
       def render?
         @enabled
       end
 
       private
 
+      sig { returns(String) }
       attr_reader :title
 
+      sig { returns(Types::HtmlAttributes) }
       def wrapper_attributes
-        attrs = {
-          class: class_names("admin-panel", {}, [ @html_options[:class] ]),
+        attrs = T.let({
+          class: component_classes("admin-panel", {}, @html_options),
           data: {
             controller: "hakumi--admin-panel",
-            'turbo-permanent': true
+            "turbo-permanent": true
           }
-        }
+        }, Types::HtmlAttributes)
 
         merge_attributes(attrs, @html_options.except(:class))
       end

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

@@ -1,19 +1,37 @@
+# typed: strict
 # frozen_string_literal: true
 
 module HakumiComponents
   module Affix
     class Component < HakumiComponents::BaseComponent
+      extend T::Sig
+
+      sig do
+        params(params: T.any(ActionController::Parameters, Types::HtmlAttributes))
+          .returns(Types::HtmlAttributes)
+      end
       def self.extract_controller_locals(params)
         {
-          body: params[:body],
-          offset_top: params[:offset_top]&.to_f,
-          offset_bottom: params[:offset_bottom]&.to_f,
-          target_selector: params[:target_selector],
-          z_index: params[:z_index]&.to_i,
-          on_change: params[:on_change]
-        }
+          body: string_html_param(html_param(params, :body)),
+          offset_top: float_html_param(html_param(params, :offset_top)),
+          offset_bottom: float_html_param(html_param(params, :offset_bottom)),
+          target_selector: string_html_param(html_param(params, :target_selector)),
+          z_index: integer_html_param(html_param(params, :z_index)),
+          on_change: string_html_param(html_param(params, :on_change))
+        }.compact
       end
 
+      sig do
+        params(
+          body: T.nilable(String),
+          offset_top: T.nilable(T.any(Numeric, String)),
+          offset_bottom: T.nilable(T.any(Numeric, String)),
+          target_selector: T.nilable(String),
+          z_index: T.nilable(Integer),
+          on_change: T.nilable(String),
+          html_options: Types::HtmlAttributeValue
+        ).void
+      end
       def initialize(
         body: nil,
         offset_top: nil,
@@ -23,61 +41,67 @@ module HakumiComponents
         on_change: nil,
         **html_options
       )
-        @body = body
-        @offset_top = normalize_numeric(offset_top)
-        @offset_bottom = normalize_numeric(offset_bottom)
-        @target_selector = target_selector
-        @z_index = normalize_numeric(z_index)&.to_i
-        @on_change = on_change
-        @html_options = html_options
+        @body = T.let(body, T.nilable(String))
+        @offset_top = T.let(normalize_offset(offset_top), T.nilable(Float))
+        @offset_bottom = T.let(normalize_offset(offset_bottom), T.nilable(Float))
+        @target_selector = T.let(target_selector, T.nilable(String))
+        @z_index = T.let(z_index, T.nilable(Integer))
+        @on_change = T.let(on_change, T.nilable(String))
+        @html_options = T.let(html_options, Types::HtmlAttributes)
 
         normalize_offsets!
         validate_props!
       end
 
+      sig { returns(Types::HtmlAttributes) }
       def root_attributes
-        base_attrs = {
-          class: class_names("affix"),
-          data: data_attributes
-        }
-
-        merge_attributes(base_attrs, @html_options)
+        merge_attributes({ class: class_names("affix"), data: data_attributes }, @html_options)
       end
 
+      sig { returns(T.nilable(Types::Renderable)) }
       def content_value
         content.presence || @body
       end
 
       private
 
+      sig { returns(Types::DataAttributes) }
       def data_attributes
-        data = { controller: "hakumi--affix" }
+        data = T.let({ controller: "hakumi--affix" }, Types::DataAttributes)
         data[:"hakumi--affix-offset-top-value"] = @offset_top unless @offset_top.nil?
         data[:"hakumi--affix-offset-bottom-value"] = @offset_bottom unless @offset_bottom.nil?
         data[:"hakumi--affix-target-selector-value"] = @target_selector if @target_selector.present?
         data[:"hakumi--affix-z-index-value"] = @z_index unless @z_index.nil?
-        data[:action] = append_action(data[:action], "hakumi--affix:change->#{@on_change}") if @on_change.present?
-        data
-      end
 
-      def normalize_numeric(value)
-        return value unless value.is_a?(String)
+        if @on_change.present?
+          existing_action = T.let(nil, T.nilable(String))
+          data[:action] = append_action(existing_action, "hakumi--affix:change->#{@on_change}")
+        end
 
-        return nil if value.strip.empty?
-
-        value.to_f
+        data
       end
 
+      sig { void }
       def normalize_offsets!
-        @offset_top = 0 if @offset_top.nil? && @offset_bottom.nil?
+        @offset_top = 0.0 if @offset_top.nil? && @offset_bottom.nil?
+      end
+
+      sig { params(value: T.nilable(T.any(Numeric, String))).returns(T.nilable(Float)) }
+      def normalize_offset(value)
+        return nil if value.nil?
+        return value.to_f if value.is_a?(Numeric)
+
+        self.class.float_html_param(value)
       end
 
+      sig { void }
       def validate_props!
         return if @offset_top.nil? || @offset_bottom.nil?
 
         raise ArgumentError, "offset_top and offset_bottom cannot be used together"
       end
 
+      sig { params(existing: T.nilable(String), action: String).returns(String) }
       def append_action(existing, action)
         return action if existing.blank?
 

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

@@ -13,8 +13,8 @@
     <% if message_content.present? %>
       <div class="hakumi-alert-message" data-hakumi--alert-target="message"><%= message_content %></div>
     <% end %>
-    <% if description? %>
-      <div class="hakumi-alert-description" data-hakumi--alert-target="description"><%= description %></div>
+    <% if description_content.present? %>
+      <div class="hakumi-alert-description" data-hakumi--alert-target="description"><%= description_content %></div>
     <% end %>
   </div>
 

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

@@ -1,51 +1,88 @@
+# typed: strict
 # frozen_string_literal: true
 
 module HakumiComponents
   module Alert
     class Component < HakumiComponents::BaseComponent
-      TYPES = [ :success, :info, :warning, :error ].freeze
+      extend T::Sig
+
+      Type = T.type_alias { T.any(Symbol, String) }
+      TYPES = T.let([ :success, :info, :warning, :error ].freeze, T::Array[Symbol])
 
-      # Slots for content
       renders_one :icon
       renders_one :message
       renders_one :description
       renders_one :action
       renders_one :close_icon
 
+      sig do
+        params(
+          params: T.any(ActionController::Parameters, HakumiComponents::Types::HtmlAttributes)
+        ).returns(HakumiComponents::Types::HtmlAttributes)
+      end
+      def self.extract_controller_locals(params)
+        {
+          type: symbol_html_param(html_param(params, :type)),
+          show_icon: boolean_html_param(html_param(params, :show_icon)),
+          closable: boolean_html_param(html_param(params, :closable)),
+          banner: boolean_html_param(html_param(params, :banner)),
+          message_text: string_html_param(html_param(params, :message)),
+          description_text: string_html_param(html_param(params, :description))
+        }.compact
+      end
+
+      sig do
+        params(
+          type: T.nilable(Type),
+          show_icon: T.nilable(T::Boolean),
+          closable: T::Boolean,
+          banner: T::Boolean,
+          message_text: T.nilable(String),
+          description_text: T.nilable(String),
+          html_options: HakumiComponents::Types::HtmlAttributeValue
+        ).void
+      end
       def initialize(
         type: nil,
         show_icon: nil,
         closable: false,
         banner: false,
+        message_text: nil,
+        description_text: nil,
         **html_options
       )
-        @type = type || :info
-        @show_icon = show_icon.nil? ? banner : show_icon
-        @closable = closable
-        @banner = banner
-        @html_options = html_options
+        @type = T.let((type || :info).to_sym, Symbol)
+        @show_icon = T.let(show_icon.nil? ? banner : show_icon, T::Boolean)
+        @closable = T.let(closable, T::Boolean)
+        @banner = T.let(banner, T::Boolean)
+        @message_text = T.let(message_text, T.nilable(String))
+        @description_text = T.let(description_text, T.nilable(String))
+        @html_options = T.let(html_options, HakumiComponents::Types::HtmlAttributes)
 
         validate_props!
       end
 
       private
 
+      sig { void }
       def validate_props!
         validate_inclusion!(:type, TYPES)
       end
 
+      sig { returns(String) }
       def wrapper_classes
-        classes = [ "hakumi-alert" ]
-        classes << "hakumi-alert-#{@type}" if @type
-        classes << "hakumi-alert-with-description" if description?
-        classes << "hakumi-alert-with-icon" if show_icon?
-        classes << "hakumi-alert-no-icon" unless show_icon?
-        classes << "hakumi-alert-closable" if @closable
-        classes << "hakumi-alert-banner" if @banner
-        classes << @html_options[:class] if @html_options[:class]
-        classes.join(" ")
+        modifiers = {
+          @type => true,
+          "with-description": description? || @description_text.present?,
+          "with-icon": show_icon?,
+          "no-icon": !show_icon?,
+          closable: @closable,
+          banner: @banner
+        }
+        component_classes("alert", modifiers, @html_options)
       end
 
+      sig { returns(HakumiComponents::Types::HtmlAttributes) }
       def wrapper_attributes
         data_attrs = { controller: "hakumi--alert" }
 
@@ -55,15 +92,27 @@ module HakumiComponents
         )
       end
 
-      # Content resolution: message slot > block content
+      sig { returns(HakumiComponents::Types::Renderable) }
       def message_content
-        message? ? message : content
+        return render_value(message) if message?
+        return render_value(content) if content.present?
+
+        render_value(@message_text)
+      end
+
+      sig { returns(HakumiComponents::Types::Renderable) }
+      def description_content
+        return render_value(description) if description?
+
+        render_value(@description_text)
       end
 
+      sig { returns(T::Boolean) }
       def show_icon?
         @show_icon
       end
 
+      sig { returns(T.nilable(ActiveSupport::SafeBuffer)) }
       def default_icon_element
         return nil unless show_icon?
 
@@ -71,6 +120,7 @@ module HakumiComponents
         render HakumiComponents::Icon::Component.new(name: icon_name)
       end
 
+      sig { returns(Symbol) }
       def default_icon_name
         case @type
         when :success then :check_circle

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

@@ -1,14 +1,26 @@
+# typed: strict
 # frozen_string_literal: true
 
 module HakumiComponents
   module Anchor
     class Component < HakumiComponents::BaseComponent
-      DIRECTIONS = %i[vertical horizontal].freeze
+      extend T::Sig
 
-      renders_many :links, ->(href:, title:, **options) do
-        HakumiComponents::Anchor::Link::Component.new(href: href, title: title, **options)
-      end
+      DIRECTIONS = T.let(%i[vertical horizontal].freeze, T::Array[Symbol])
+
+      renders_many :links, HakumiComponents::Anchor::Link::Component
 
+      sig do
+        params(
+          affix: T::Boolean,
+          bounds: Numeric,
+          offset_top: Numeric,
+          target_offset: T.nilable(Numeric),
+          direction: Symbol,
+          replace: T::Boolean,
+          html_options: Types::HtmlAttributeValue
+        ).void
+      end
       def initialize(
         affix: true,
         bounds: 5,
@@ -18,60 +30,56 @@ module HakumiComponents
         replace: false,
         **html_options
       )
-        @affix = affix
-        @bounds = bounds
-        @offset_top = offset_top
-        @target_offset = target_offset
-        @direction = direction
-        @replace = replace
-        @html_options = html_options
+        @affix = T.let(affix, T::Boolean)
+        @bounds = T.let(bounds, Numeric)
+        @offset_top = T.let(offset_top, Numeric)
+        @target_offset = T.let(target_offset, T.nilable(Numeric))
+        @direction = T.let(direction, Symbol)
+        @replace = T.let(replace, T::Boolean)
+        @html_options = T.let(html_options, Types::HtmlAttributes)
 
         validate_props!
       end
 
+      sig { returns(String) }
       def wrapper_classes
-        classes = [ "hakumi-anchor-wrapper" ]
-        classes << "hakumi-anchor-wrapper-fixed" if @affix
-        classes << "hakumi-anchor-wrapper-horizontal" if horizontal?
-        classes.join(" ")
+        class_names("anchor-wrapper", { fixed: @affix, horizontal: horizontal? })
       end
 
+      sig { returns(String) }
       def anchor_classes
-        classes = [ "hakumi-anchor" ]
-        classes << "hakumi-anchor-fixed" if @affix
-        classes.join(" ")
+        class_names("anchor", { fixed: @affix })
       end
 
+      sig { returns(String) }
       def stimulus_controller
         "hakumi--anchor"
       end
 
-      def stimulus_values
-        {
+      sig { returns(Types::HtmlAttributes) }
+      def wrapper_attributes
+        values = T.let({
           offset_top: @offset_top,
           target_offset: @target_offset || @offset_top,
           bounds: @bounds,
           replace: @replace,
           direction: @direction.to_s
-        }.compact
-      end
-
-      def wrapper_attributes
-        base_data = stimulus_values.transform_keys { |k| "#{stimulus_controller}-#{k.to_s.dasherize}-value" }
-        base_data[:controller] = stimulus_controller
+        }, Types::StimulusValues)
 
         merge_attributes(
-          { class: wrapper_classes, data: base_data },
+          { class: wrapper_classes, data: stimulus_attrs(stimulus_controller, values) },
           @html_options
         )
       end
 
+      sig { returns(T::Boolean) }
       def horizontal?
         @direction == :horizontal
       end
 
       private
 
+      sig { void }
       def validate_props!
         validate_inclusion!(:direction, DIRECTIONS)
       end

data/app/components/hakumi_components/anchor/link/component.html.erb

@@ -4,7 +4,7 @@
     href="<%= href %>"
     title="<%= title %>"
     <% if target.present? %> target="<%= target %>"<% end %>><%= title %></a>
-  <% if has_children? %>
+  <% if children? %>
     <% links.each do |child_link| %>
       <%= child_link %>
     <% end %>

data/app/components/hakumi_components/anchor/link/component.rb

@@ -1,31 +1,50 @@
+# typed: strict
 # frozen_string_literal: true
 
 module HakumiComponents
   module Anchor
     module Link
       class Component < HakumiComponents::BaseComponent
-        renders_many :links, ->(href:, title:, **options) do
-          HakumiComponents::Anchor::Link::Component.new(href: href, title: title, **options)
-        end
+        extend T::Sig
+
+        renders_many :links, HakumiComponents::Anchor::Link::Component
 
+        sig do
+          params(
+            href: String,
+            title: String,
+            target: T.nilable(String),
+            html_options: Types::HtmlAttributeValue
+          ).void
+        end
         def initialize(href:, title:, target: nil, **html_options)
-          @href = href
-          @title = title
-          @target = target
-          @html_options = html_options
+          @href = T.let(href, String)
+          @title = T.let(title, String)
+          @target = T.let(target, T.nilable(String))
+          @html_options = T.let(html_options, Types::HtmlAttributes)
         end
 
-        attr_reader :href, :title, :target
+        sig { returns(String) }
+        attr_reader :href
+
+        sig { returns(String) }
+        attr_reader :title
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :target
 
+        sig { returns(String) }
         def link_classes
           "hakumi-anchor-link"
         end
 
+        sig { returns(String) }
         def title_classes
           "hakumi-anchor-link-title"
         end
 
-        def has_children?
+        sig { returns(T::Boolean) }
+        def children?
           links.any?
         end
       end