hakumi_components 0.1.17.pre → 0.1.19.pre

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

@@ -0,0 +1,113 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Radio
+    class Component < HakumiComponents::BaseComponent
+      extend T::Sig
+
+      include HakumiComponents::Concerns::FormField
+
+      sig do
+        params(
+          name: Types::FormFieldName,
+          value: HakumiComponents::Types::FormFieldScalar,
+          text: Types::Renderable,
+          label: T.nilable(String),
+          caption: T.nilable(String),
+          checked: T::Boolean,
+          disabled: T::Boolean,
+          size: Symbol,
+          id: T.nilable(Types::FormFieldName),
+          auto_focus: T::Boolean,
+          required: T::Boolean,
+          standalone: T::Boolean,
+          errors: Types::FormFieldErrors,
+          html_options: Types::HtmlAttributeValue
+        ).void
+      end
+      def initialize(
+        name:,
+        value: nil,
+        text: nil,
+        label: nil,
+        caption: nil,
+        checked: false,
+        disabled: false,
+        size: :default,
+        id: nil,
+        auto_focus: false,
+        required: false,
+        standalone: true,
+        errors: [],
+        **html_options
+      )
+        @name = name
+        @value = T.let(value, HakumiComponents::Types::FormFieldScalar)
+        @text = text
+        @label = label
+        @caption = caption
+        @checked = checked
+        @disabled = disabled
+        @size = size
+        @id = T.let(id || generate_id("radio"), Types::FormFieldName)
+        @auto_focus = auto_focus
+        @required = required
+        @standalone = standalone
+        @errors = T.let(errors, Types::FormFieldErrors)
+        @html_options = T.let(html_options, Types::HtmlAttributes)
+        @html_options[:id] ||= @id
+        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(String) }
+      def wrapper_classes
+        modifiers = {
+          checked: @checked,
+          disabled: @disabled
+        }
+        modifiers[@size] = true if @size != :default
+
+        class_names("radio-wrapper", modifiers)
+      end
+
+      sig { returns(String) }
+      def radio_classes
+        modifiers = {
+          checked: @checked,
+          disabled: @disabled
+        }
+        modifiers[@size] = true if @size != :default
+
+        class_names("radio", modifiers)
+      end
+
+      sig { returns(String) }
+      def data_controllers
+        "hakumi--radio"
+      end
+
+      sig { returns(Types::Renderable) }
+      def label_text
+        @text || content
+      end
+
+      private
+
+      sig { void }
+      def validate_props!
+        validate_inclusion!(:size, SIZES)
+      end
+    end
+  end
+end

data/app/components/{hakumi → hakumi_components}/radio/group/component.html.erb

@@ -2,11 +2,11 @@
   <%= tag.div(**wrapper_attributes) do %>
     <% normalized_options.each_with_index do |option, index| %>
       <% if button_group? %>
-        <label class="<%= button_wrapper_classes(option) %>" data-controller="hakumi--radio" data-hakumi--radio-checked-value="<%= option_checked?(option[:value]) %>" data-hakumi--radio-variant-value="button">
+        <label class="<%= button_wrapper_classes(option) %>" data-controller="hakumi--radio" data-hakumi--radio-checked-value="<%= option_checked?(option.value) %>" data-hakumi--radio-variant-value="button">
           <%= radio_button_tag(
-                @name,
-                option[:value],
-                option_checked?(option[:value]),
+                form_field_name,
+                option.value,
+                option_checked?(option.value),
                 id: option_id(index),
                 class: "hakumi-radio-button-input",
                 disabled: option_disabled?(option),
@@ -15,16 +15,16 @@
                   action: "change->hakumi--radio#toggle"
                 }
               ) %>
-          <span class="hakumi-radio-button-label"><%= option[:label] %></span>
+          <span class="hakumi-radio-button-label"><%= option.label %></span>
         </label>
       <% else %>
-        <%= render Hakumi::Radio::Component.new(
-              name: @name,
-              value: option[:value],
-              checked: option_checked?(option[:value]),
+        <%= render HakumiComponents::Radio::Component.new(
+              name: form_field_name,
+              value: option.value,
+              checked: option_checked?(option.value),
               disabled: option_disabled?(option),
               size: @size,
-              text: option[:label]
+              text: option.label
             ) %>
       <% end %>
     <% end %>

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

@@ -0,0 +1,181 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Radio
+    module Group
+      class Component < HakumiComponents::BaseComponent
+        extend T::Sig
+
+        include HakumiComponents::Concerns::FormField
+
+        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,
+          options: [],
+          label: nil,
+          caption: nil,
+          variant: :default,
+          direction: :horizontal,
+          size: :default,
+          disabled: false,
+          standalone: true,
+          required: false,
+          errors: [],
+          **html_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 = T.let(variant.to_sym, Symbol)
+          @direction = T.let(direction.to_sym, Symbol)
+          @size = size
+          @disabled = disabled
+          @standalone = standalone
+          @required = required
+          @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,
+            role: "radiogroup",
+            "aria-orientation": (@direction == :vertical ? "vertical" : nil)
+          }.compact
+
+          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
+        end
+
+        sig { params(option: HakumiComponents::Radio::Group::Option).returns(String) }
+        def button_wrapper_classes(option)
+          modifiers = {
+            checked: option_checked?(option.value),
+            disabled: option_disabled?(option)
+          }
+          modifiers[@size] = true if @size != :default
+
+          class_names("radio-button-wrapper", modifiers)
+        end
+
+        sig { params(index: Integer).returns(String) }
+        def option_id(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 != :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)
+          options.map do |option|
+            next option if option.is_a?(HakumiComponents::Radio::Group::Option)
+
+            if option.is_a?(Hash)
+              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?
+
+              HakumiComponents::Radio::Group::Option.new(
+                label: normalize_option_label(label_value),
+                value: value_value,
+                disabled: !!(option[:disabled] || option["disabled"])
+              )
+            else
+              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)
+          validate_inclusion!(:direction, DIRECTIONS)
+        end
+      end
+    end
+  end
+end

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 → hakumi_components}/rate/component.html.erb

@@ -18,7 +18,7 @@
           <span class="hakumi-rate-star-second"><%= character_content %></span>
         <% end %>
         <% if tooltip_text.present? %>
-          <%= render Hakumi::Tooltip::Component.new(title: tooltip_text) do %>
+          <%= render HakumiComponents::Tooltip::Component.new(title: tooltip_text) do %>
             <%= star_element %>
           <% end %>
         <% else %>
@@ -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 → hakumi_components}/rate/component.rb

@@ -1,12 +1,33 @@
+# typed: strict
 # frozen_string_literal: true
 
-module Hakumi
+module HakumiComponents
   module Rate
-    # Hakumi Rate component
-    # Supports half selection, clearing, and form integration.
-    class Component < Hakumi::BaseComponent
-      include Hakumi::Concerns::FormField
+    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 Hakumi
         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 Hakumi
         @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 Hakumi
             "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 Hakumi
         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 Hakumi
         :zero
       end
 
+      sig { params(state: Symbol).returns(String) }
       def star_classes(state)
         class_names(
           "rate-star",
@@ -104,28 +139,39 @@ module Hakumi
         )
       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