hakumi_components 0.1.18.pre → 0.1.19.pre

data/app/components/hakumi_components/radio/group/component.rb

@@ -1,15 +1,41 @@
+# typed: strict
 # frozen_string_literal: true
 
 module HakumiComponents
   module Radio
     module Group
       class Component < HakumiComponents::BaseComponent
+        extend T::Sig
+
         include HakumiComponents::Concerns::FormField
 
-        SIZES = [ :small, :middle, :large ].freeze
-        VARIANTS = [ :default, :button, :solid ].freeze
-        DIRECTIONS = [ :horizontal, :vertical ].freeze
+        OptionHash = T.type_alias do
+          T::Hash[T.any(Symbol, String), T.nilable(T.any(String, Symbol, Numeric, T::Boolean))]
+        end
+        OptionInput = T.type_alias do
+          T.any(HakumiComponents::Radio::Group::Option, OptionHash, String, Symbol, Numeric)
+        end
 
+        VARIANTS = T.let([ :default, :button, :solid ].freeze, T::Array[Symbol])
+        DIRECTIONS = T.let([ :horizontal, :vertical ].freeze, T::Array[Symbol])
+
+        sig do
+          params(
+            name: T.nilable(Types::FormFieldName),
+            value: HakumiComponents::Types::FormFieldScalar,
+            options: T::Array[OptionInput],
+            label: T.nilable(String),
+            caption: T.nilable(String),
+            variant: Symbol,
+            direction: Symbol,
+            size: Symbol,
+            disabled: T::Boolean,
+            standalone: T::Boolean,
+            required: T::Boolean,
+            errors: Types::FormFieldErrors,
+            html_options: Types::HtmlAttributeValue
+          ).void
+        end
         def initialize(
           name: nil,
           value: nil,
@@ -18,30 +44,40 @@ module HakumiComponents
           caption: nil,
           variant: :default,
           direction: :horizontal,
-          size: :middle,
+          size: :default,
           disabled: false,
           standalone: true,
           required: false,
           errors: [],
           **html_options
         )
-          @name = name || generate_id("radio_group")
-          @value = value
-          @options = normalize_options(options)
+          @name = T.let(name || generate_id("radio_group"), Types::FormFieldName)
+          @value = T.let(value, HakumiComponents::Types::FormFieldScalar)
+          @options = T.let(normalize_options(options), T::Array[HakumiComponents::Radio::Group::Option])
           @label = label
           @caption = caption
-          @variant = variant.to_sym
-          @direction = direction.to_sym
+          @variant = T.let(variant.to_sym, Symbol)
+          @direction = T.let(direction.to_sym, Symbol)
           @size = size
           @disabled = disabled
           @standalone = standalone
           @required = required
-          @errors = Array(errors)
-          @html_options = html_options
+          @errors = T.let(errors, Types::FormFieldErrors)
+          @html_options = T.let(html_options, Types::HtmlAttributes)
+          initialize_form_field_contract!(
+            name: @name,
+            label: @label,
+            caption: @caption,
+            errors: @errors,
+            standalone: @standalone,
+            required: @required,
+            html_options: @html_options
+          )
 
           validate_props!
         end
 
+        sig { returns(Types::HtmlAttributes) }
         def wrapper_attributes
           attrs = {
             class: wrapper_classes,
@@ -52,75 +88,88 @@ module HakumiComponents
           merge_attributes(attrs, @html_options)
         end
 
+        sig { returns(T::Array[HakumiComponents::Radio::Group::Option]) }
         def normalized_options
           @options
         end
 
+        sig { params(option_value: HakumiComponents::Types::FormFieldScalar).returns(T::Boolean) }
         def option_checked?(option_value)
           return false if @value.nil?
 
           @value.to_s == option_value.to_s
         end
 
+        sig { params(option: HakumiComponents::Radio::Group::Option).returns(T::Boolean) }
         def option_disabled?(option)
-          @disabled || option[:disabled]
+          @disabled || option.disabled
         end
 
+        sig { params(option: HakumiComponents::Radio::Group::Option).returns(String) }
         def button_wrapper_classes(option)
           modifiers = {
-            checked: option_checked?(option[:value]),
+            checked: option_checked?(option.value),
             disabled: option_disabled?(option)
           }
-          modifiers[@size] = true if @size != :middle
+          modifiers[@size] = true if @size != :default
 
           class_names("radio-button-wrapper", modifiers)
         end
 
+        sig { params(index: Integer).returns(String) }
         def option_id(index)
-          "#{@name}_#{index}"
+          "#{form_field_name}_#{index}"
         end
 
+        sig { returns(T::Boolean) }
         def button_group?
           @variant == :button || @variant == :solid
         end
 
         private
 
+        sig { returns(String) }
         def wrapper_classes
           modifiers = {
             button: button_group?,
             vertical: @direction == :vertical,
             disabled: @disabled
           }
-          modifiers[@size] = true if @size != :middle
+          modifiers[@size] = true if @size != :default
           modifiers[:solid] = true if @variant == :solid
           modifiers[:outline] = true if @variant == :button
 
           class_names("radio-group", modifiers)
         end
 
+        sig { params(options: T::Array[OptionInput]).returns(T::Array[HakumiComponents::Radio::Group::Option]) }
         def normalize_options(options)
-          Array(options).map do |option|
+          options.map do |option|
+            next option if option.is_a?(HakumiComponents::Radio::Group::Option)
+
             if option.is_a?(Hash)
-              option = option.deep_symbolize_keys if option.respond_to?(:deep_symbolize_keys)
-              label_value = option[:label]
-              value_value = option[:value] || label_value
+              label_value = option[:label] || option["label"]
+              value_value = option[:value] || option["value"] || label_value
 
               raise ArgumentError, "Option must have :label key" if label_value.nil?
 
-              {
-                label: label_value,
+              HakumiComponents::Radio::Group::Option.new(
+                label: normalize_option_label(label_value),
                 value: value_value,
-                disabled: !!option[:disabled]
-              }
-            elsif option.is_a?(String)
-              { label: option, value: option, disabled: false }
+                disabled: !!(option[:disabled] || option["disabled"])
+              )
             else
-              raise ArgumentError, "Option must be a Hash with :label and :value, or a String. Got: #{option.class}"
+              HakumiComponents::Radio::Group::Option.new(label: option, value: option, disabled: false)
             end
           end
         end
 
+        sig { params(label: T.any(String, Symbol, Numeric, T::Boolean)).returns(T.any(String, Symbol, Numeric)) }
+        def normalize_option_label(label)
+          label == true || label == false ? label.to_s : label
+        end
+
+        sig { void }
         def validate_props!
           validate_inclusion!(:size, SIZES)
           validate_inclusion!(:variant, VARIANTS)

data/app/components/hakumi_components/radio/group/option.rb

@@ -0,0 +1,43 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Radio
+    module Group
+      class Option
+        extend T::Sig
+
+        sig do
+          params(
+            label: T.any(String, Symbol, Numeric),
+            value: HakumiComponents::Types::FormFieldScalar,
+            disabled: T::Boolean
+          ).void
+        end
+        def initialize(label:, value:, disabled: false)
+          @label = label
+          @value = value
+          @disabled = disabled
+        end
+
+        sig { returns(T.any(String, Symbol, Numeric)) }
+        attr_reader :label
+
+        sig { returns(HakumiComponents::Types::FormFieldScalar) }
+        attr_reader :value
+
+        sig { returns(T::Boolean) }
+        attr_reader :disabled
+
+        sig { returns(T::Hash[Symbol, T.any(T.any(String, Symbol, Numeric), HakumiComponents::Types::FormFieldScalar, T::Boolean)]) }
+        def to_h
+          {
+            label: @label,
+            value: @value,
+            disabled: @disabled
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -29,7 +29,7 @@
   </div>
 <% end %>
 
-<% if @standalone %>
+<% if standalone? %>
   <%= rate_control %>
 <% else %>
   <div <%= tag.attributes(form_item_attributes).to_s.html_safe %>>

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

@@ -1,12 +1,33 @@
+# typed: strict
 # frozen_string_literal: true
 
 module HakumiComponents
   module Rate
-    # Hakumi Rate component
-    # Supports half selection, clearing, and form integration.
     class Component < HakumiComponents::BaseComponent
+      extend T::Sig
+
       include HakumiComponents::Concerns::FormField
 
+      sig do
+        params(
+          name: T.nilable(Types::FormFieldName),
+          label: T.nilable(String),
+          caption: T.nilable(String),
+          value: T.nilable(T.any(Numeric, String)),
+          default_value: T.any(Numeric, String),
+          count: Integer,
+          allow_half: T::Boolean,
+          allow_clear: T::Boolean,
+          disabled: T::Boolean,
+          readonly: T::Boolean,
+          tooltips: T::Array[String],
+          character: Types::Renderable,
+          required: T::Boolean,
+          standalone: T::Boolean,
+          errors: Types::FormFieldErrors,
+          html_options: Types::HtmlAttributeValue
+        ).void
+      end
       def initialize(
         name: nil,
         label: nil,
@@ -25,7 +46,7 @@ module HakumiComponents
         errors: [],
         **html_options
       )
-        @name = name || generate_id("rate")
+        @name = T.let(name || generate_id("rate"), Types::FormFieldName)
         @label = label
         @caption = caption
         @value = value
@@ -35,19 +56,30 @@ module HakumiComponents
         @allow_clear = allow_clear
         @disabled = disabled
         @readonly = readonly
-        @tooltips = Array(tooltips)
+        @tooltips = T.let(tooltips, T::Array[String])
         @character = character
         @required = required
         @standalone = standalone
-        @errors = Array(errors)
-        @html_options = html_options
+        @errors = T.let(errors, Types::FormFieldErrors)
+        @html_options = T.let(html_options, Types::HtmlAttributes)
+        initialize_form_field_contract!(
+          name: @name,
+          label: @label,
+          caption: @caption,
+          errors: @errors,
+          standalone: @standalone,
+          required: @required,
+          html_options: @html_options
+        )
       end
 
+      sig { returns(Float) }
       def current_value
         base_value = @value.nil? ? @default_value : @value
         base_value.to_f
       end
 
+      sig { returns(String) }
       def rate_classes
         class_names(
           "rate",
@@ -57,10 +89,11 @@ module HakumiComponents
             "allow-clear": @allow_clear,
             "has-value": current_value.positive?
           },
-          [ @html_options[:class] ]
+          [ html_class_name ]
         )
       end
 
+      sig { returns(Types::HtmlAttributes) }
       def rate_wrapper_attributes
         base_attrs = {
           class: rate_classes,
@@ -85,6 +118,7 @@ module HakumiComponents
         merge_attributes(base_attrs, @html_options.except(:class))
       end
 
+      sig { params(index: Integer).returns(Symbol) }
       def star_state(index)
         value = current_value
         return :full if value >= index + 1
@@ -93,6 +127,7 @@ module HakumiComponents
         :zero
       end
 
+      sig { params(state: Symbol).returns(String) }
       def star_classes(state)
         class_names(
           "rate-star",
@@ -104,28 +139,39 @@ module HakumiComponents
         )
       end
 
+      sig { params(index: Integer).returns(T.nilable(String)) }
       def tooltip_for(index)
         @tooltips[index]
       end
 
+      sig { returns(Types::Renderable) }
       def character_content
         render_value(@character || "★")
       end
 
+      sig { returns(Types::HtmlAttributes) }
       def input_attributes
         {
           type: "hidden",
-          name: @name,
+          name: form_field_name,
           id: input_id,
           value: current_value,
           disabled: @disabled ? true : nil,
-          "aria-invalid": has_error? ? "true" : nil,
+          "aria-invalid": error? ? "true" : nil,
           "aria-describedby": describedby_ids,
           data: {
             hakumi__rate_target: "input"
           }
         }.compact
       end
+
+      private
+
+      sig { returns(T.nilable(String)) }
+      def html_class_name
+        css_class = @html_options[:class]
+        css_class.is_a?(String) ? css_class : nil
+      end
     end
   end
 end

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

@@ -1,46 +1,77 @@
+# typed: strict
 # frozen_string_literal: true
 
 module HakumiComponents
   module Result
     class Component < HakumiComponents::BaseComponent
-      STATUSES = %w[success info warning error].freeze
-
-      DEFAULT_TITLES = {
-        "success" => "Success",
-        "info" => "Information",
-        "warning" => "Warning",
-        "error" => "Error"
-      }.freeze
-
-      DEFAULT_ICON_NAME = "result_success"
-      STATUS_ICON_MAP = {
-        "success" => { name: "check-circle", theme: :filled, color: "var(--color-success)" },
-        "info" => { name: "info-circle", theme: :filled, color: "var(--color-primary)" },
-        "warning" => { name: "exclamation-circle", theme: :filled, color: "var(--color-warning)" },
-        "error" => { name: "close-circle", theme: :filled, color: "var(--color-error)" }
-      }.freeze
-      STATUS_ICON_SIZE = 72
-
+      extend T::Sig
+
+      Status = T.type_alias { T.any(Symbol, String) }
+      IconOverride = T.type_alias { T.any(FalseClass, HakumiComponents::Types::Renderable) }
+      STATUSES = T.let(%i[success info warning error].freeze, T::Array[Symbol])
+
+      DEFAULT_TITLES = T.let({
+        success: "Success",
+        info: "Information",
+        warning: "Warning",
+        error: "Error"
+      }.freeze, T::Hash[Symbol, String])
+
+      DEFAULT_ICON_NAME = T.let("result_success", String)
+      STATUS_ICON_MAP = T.let({
+        success: [ "check-circle", :filled, "var(--color-success)" ],
+        info: [ "info-circle", :filled, "var(--color-primary)" ],
+        warning: [ "exclamation-circle", :filled, "var(--color-warning)" ],
+        error: [ "close-circle", :filled, "var(--color-error)" ]
+      }.freeze, T::Hash[Symbol, [ String, Symbol, String ]])
+      STATUS_ICON_SIZE = T.let(72, Integer)
+
+      renders_one :title
+      renders_one :sub_title
+      renders_one :extra
+
+      sig do
+        params(
+          params: T.any(ActionController::Parameters, HakumiComponents::Types::HtmlAttributes)
+        ).returns(HakumiComponents::Types::HtmlAttributes)
+      end
       def self.extract_controller_locals(params)
         {
-          status: params[:status],
-          title: params[:title],
-          sub_title: params[:sub_title],
-          extra: params[:extra]
+          status: symbol_html_param(html_param(params, :status)),
+          title: html_primitive_param(html_param(params, :title)),
+          sub_title: html_primitive_param(html_param(params, :sub_title)),
+          icon: icon_html_param(html_param(params, :icon)),
+          extra: html_primitive_param(html_param(params, :extra))
         }
       end
 
+      sig { params(value: HakumiComponents::Types::HtmlAttributeValue).returns(T.nilable(FalseClass)) }
+      def self.icon_html_param(value)
+        boolean_html_param(value) == false ? false : nil
+      end
+
+      sig do
+        params(
+          status: Status,
+          title: HakumiComponents::Types::Renderable,
+          sub_title: HakumiComponents::Types::Renderable,
+          icon: T.nilable(IconOverride),
+          extra: HakumiComponents::Types::Renderable,
+          html_options: HakumiComponents::Types::HtmlAttributeValue
+        ).void
+      end
       def initialize(status: :info, title: nil, sub_title: nil, icon: nil, extra: nil, **html_options)
-        @status = (status || :info).to_s
-        @title = title || DEFAULT_TITLES[@status]
-        @sub_title = sub_title
-        @icon = icon
-        @extra = extra
-        @html_options = html_options
+        @status = T.let(status.to_sym, Symbol)
+        @title = T.let(title || DEFAULT_TITLES[@status], HakumiComponents::Types::Renderable)
+        @sub_title = T.let(sub_title, HakumiComponents::Types::Renderable)
+        @icon = T.let(icon, T.nilable(IconOverride))
+        @extra = T.let(extra, HakumiComponents::Types::Renderable)
+        @html_options = T.let(html_options, HakumiComponents::Types::HtmlAttributes)
 
         validate_props!
       end
 
+      sig { returns(HakumiComponents::Types::HtmlAttributes) }
       def wrapper_attributes
         merge_attributes(
           {
@@ -52,71 +83,90 @@ module HakumiComponents
         )
       end
 
+      sig { returns(T::Boolean) }
       def icon_present?
         @icon != false
       end
 
+      sig { returns(HakumiComponents::Types::Renderable) }
       def icon_content
         return nil unless icon_present?
 
         render_value(@icon || status_icon_component || default_icon)
       end
 
+      sig { returns(HakumiComponents::Types::Renderable) }
       def title_content
+        return render_value(title) if title?
+
         render_value(@title)
       end
 
+      sig { returns(HakumiComponents::Types::Renderable) }
       def sub_title_content
+        return render_value(sub_title) if sub_title?
+
         render_value(@sub_title)
       end
 
+      sig { returns(HakumiComponents::Types::Renderable) }
       def extra_content
+        return render_value(extra) if extra?
+
         render_value(@extra)
       end
 
+      sig { returns(T::Boolean) }
       def content_present?
         content.present?
       end
 
+      sig { returns(T::Boolean) }
       def extra_present?
-        @extra.present?
+        extra? || @extra.present?
       end
 
+      sig { returns(T::Boolean) }
       def title_present?
-        @title.present?
+        title? || @title.present?
       end
 
+      sig { returns(T::Boolean) }
       def sub_title_present?
-        @sub_title.present?
+        sub_title? || @sub_title.present?
       end
 
       private
 
+      sig { void }
       def validate_props!
         validate_inclusion!(:status, STATUSES)
       end
 
+      sig { returns(String) }
       def wrapper_classes
-        class_names(
+        component_classes(
           "result",
           { @status => true },
-          [ @html_options[:class] ]
+          @html_options
         )
       end
 
-
+      sig { returns(T.nilable(HakumiComponents::Icon::Component)) }
       def status_icon_component
         config = STATUS_ICON_MAP[@status]
         return unless config
 
+        name, theme, color = config
         HakumiComponents::Icon::Component.new(
-          name: config[:name],
-          theme: config[:theme],
+          name: name,
+          theme: theme,
           size: STATUS_ICON_SIZE,
-          color: config[:color]
+          color: color
         )
       end
 
+      sig { returns(HakumiComponents::Types::Renderable) }
       def default_icon
         HakumiComponents::Illustrations::Loader.load(DEFAULT_ICON_NAME)
       end

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

@@ -4,7 +4,7 @@
     <%= tag.label(class: option_classes(option), data: option_data_attributes(option)) do %>
       <%= radio_button_tag(
             @name,
-            option[:value],
+            option.value,
             option_selected?(option),
             **option_input_attributes(option, index)
           ) %>