hakumi_components 0.1.18.pre → 0.1.19.pre

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

@@ -1,46 +1,82 @@
+# typed: strict
 # frozen_string_literal: true
 
 module HakumiComponents
   module QrCode
     class Component < HakumiComponents::BaseComponent
-      TYPES = [ :canvas, :svg ].freeze
-      STATUSES = [ :active, :expired, :loading, :scanned ].freeze
-      ERROR_LEVELS = [ :L, :M, :Q, :H ].freeze
-
+      extend T::Sig
+
+      NumberValue = T.type_alias { Numeric }
+      NumberInput = T.type_alias { BaseComponent::DimensionInput }
+      OptionInput = T.type_alias { BaseComponent::SymbolInput }
+      IconRenderable = T.type_alias { T.nilable(Types::ComponentRenderable) }
+      IconInput = T.type_alias { T.nilable(T.any(Symbol, Types::Renderable)) }
+      StatusRender = T.type_alias { T.nilable(T.any(Types::Renderable, T.proc.params(status: Symbol).returns(Types::RenderedContent))) }
+      ControllerOptions = T.type_alias { BaseComponent::ControllerOptions }
+      ImageAttributes = T.type_alias { T::Hash[Symbol, Types::HtmlPrimitive] }
+      TYPES = T.let([ :canvas, :svg ].freeze, T::Array[Symbol])
+      STATUSES = T.let([ :active, :expired, :loading, :scanned ].freeze, T::Array[Symbol])
+      ERROR_LEVELS = T.let([ :L, :M, :Q, :H ].freeze, T::Array[Symbol])
+
+      sig do
+        params(params: ControllerOptions).returns(Types::HtmlAttributes)
+      end
       def self.extract_controller_locals(params)
+        bordered_value = html_param(params, :bordered)
+
         {
-          value: params[:value],
-          size: parse_number(params[:size]),
-          type: params[:type]&.to_sym,
-          color: params[:color],
-          bg_color: params[:bg_color],
-          icon: params[:icon],
-          icon_size: parse_number(params[:icon_size]),
-          status: params[:status]&.to_sym,
-          status_render: params[:status_render],
-          bordered: params.key?(:bordered) ? ActiveModel::Type::Boolean.new.cast(params[:bordered]) : nil,
-          error_level: parse_error_level(params[:error_level]),
-          download_name: params[:download_name],
-          aria_label: params[:aria_label]
+          value: string_html_param(html_param(params, :value)),
+          size: parse_number(html_param(params, :size)),
+          type: symbol_html_param(html_param(params, :type)),
+          color: string_html_param(html_param(params, :color)),
+          bg_color: string_html_param(html_param(params, :bg_color)),
+          icon: html_param(params, :icon),
+          icon_size: parse_number(html_param(params, :icon_size)),
+          status: symbol_html_param(html_param(params, :status)),
+          status_render: string_html_param(html_param(params, :status_render)),
+          bordered: bordered_value.nil? ? nil : boolean_html_param(bordered_value),
+          error_level: parse_error_level(html_param(params, :error_level)),
+          download_name: string_html_param(html_param(params, :download_name)),
+          aria_label: string_html_param(html_param(params, :aria_label))
         }
       end
 
+      sig { params(value: Types::HtmlAttributeValue).returns(T.nilable(NumberValue)) }
       def self.parse_number(value)
         return nil if value.nil?
-        return value if value.is_a?(Numeric)
+        return value if value.is_a?(Integer)
+        return value if value.is_a?(Float)
         raw = value.to_s.strip
         return nil if raw.empty?
 
-        number = raw.to_f
-        number == number.to_i ? number.to_i : number
+        raw.include?(".") ? raw.to_f : raw.to_i
       end
 
+      sig { params(value: Types::HtmlAttributeValue).returns(T.nilable(Symbol)) }
       def self.parse_error_level(value)
         return nil if value.nil?
 
         value.to_s.strip.presence&.upcase&.to_sym
       end
 
+      sig do
+        params(
+          value: String,
+          size: NumberInput,
+          type: OptionInput,
+          color: T.nilable(String),
+          bg_color: T.nilable(String),
+          icon: IconInput,
+          icon_size: NumberInput,
+          status: OptionInput,
+          status_render: StatusRender,
+          bordered: T.nilable(T::Boolean),
+          error_level: OptionInput,
+          download_name: T.nilable(String),
+          aria_label: T.nilable(String),
+          html_options: Types::HtmlAttributeValue
+        ).void
+      end
       def initialize(
         value:,
         size: 160,
@@ -57,32 +93,33 @@ module HakumiComponents
         aria_label: nil,
         **html_options
       )
-        @value = value
-        @size = self.class.parse_number(size) || 160
-        @type = normalize_symbol(type) || :canvas
-        @color = normalize_string(color)
-        @bg_color = normalize_string(bg_color)
-        @icon_input = icon
-        @icon_size = self.class.parse_number(icon_size) || 40
+        @value = T.let(value, String)
+        @size = T.let(self.class.parse_number(size) || 160, NumberValue)
+        @type = T.let(normalize_symbol(type) || :canvas, Symbol)
+        @color = T.let(normalize_string(color), T.nilable(String))
+        @bg_color = T.let(normalize_string(bg_color), T.nilable(String))
+        @icon_input = T.let(icon, IconInput)
+        @icon_size = T.let(self.class.parse_number(icon_size) || 40, NumberValue)
         resolve_icon!
-        @status = normalize_symbol(status) || :active
-        @status_render = status_render
-        @bordered = bordered.nil? ? true : ActiveModel::Type::Boolean.new.cast(bordered)
-        @error_level = normalize_error_level(error_level) || :M
-        @download_name = normalize_string(download_name)
-        @aria_label = normalize_string(aria_label)
-        @html_options = html_options
+        @status = T.let(normalize_symbol(status) || :active, Symbol)
+        @status_render = T.let(status_render, StatusRender)
+        @bordered = T.let(bordered.nil? ? true : cast_boolean(bordered) == true, T::Boolean)
+        @error_level = T.let(normalize_error_level(error_level) || :M, Symbol)
+        @download_name = T.let(normalize_string(download_name), T.nilable(String))
+        @aria_label = T.let(normalize_string(aria_label), T.nilable(String))
+        @html_options = T.let(html_options, Types::HtmlAttributes)
 
         validate_props!
       end
 
+      sig { returns(Types::HtmlAttributes) }
       def wrapper_attributes
         merge_attributes(
           {
             class: wrapper_classes,
             style: wrapper_styles,
             role: "img",
-            "aria-label": @aria_label || "QR Code",
+            "aria-label": @aria_label || t_default(:aria_label, default: "QR Code"),
             "aria-busy": loading? ? "true" : "false",
             data: data_attributes
           },
@@ -90,39 +127,46 @@ module HakumiComponents
         )
       end
 
+      sig { returns(Types::HtmlAttributes) }
       def renderer_attributes
-        {
+        T.let({
           class: "hakumi-qr-code-inner",
           data: { "hakumi--qr-code-target": "renderer" }
-        }
+        }, Types::HtmlAttributes)
       end
 
+      sig { returns(T::Boolean) }
       def icon?
         icon_component? || icon_image?
       end
 
+      sig { returns(Types::RenderedContent) }
       def icon_markup
+        icon_component = @icon_component
         if icon_image?
           tag.img(**icon_image_attributes)
-        elsif icon_component?
-          render(@icon_component)
+        elsif !icon_component.nil?
+          render(icon_component)
         end
       end
 
+      sig { returns(ImageAttributes) }
       def icon_image_attributes
-        {
+        T.let({
           src: @icon_url,
           alt: "",
           class: "hakumi-qr-code-icon-image",
           "aria-hidden": true,
           role: "presentation"
-        }
+        }, ImageAttributes)
       end
 
+      sig { returns(T::Boolean) }
       def status_overlay?
         @status != :active
       end
 
+      sig { returns(Types::RenderedContent) }
       def status_overlay_markup
         return nil unless status_overlay?
 
@@ -132,25 +176,25 @@ module HakumiComponents
         default_status_overlay
       end
 
+      sig { returns(String) }
       def status_text
-        case @status
-        when :expired
-          "Expired"
-        when :loading
-          "Loading"
-        when :scanned
-          "Scanned"
-        else
-          "Active"
+        key = "status.#{@status}"
+        default = case @status
+        when :expired then "Expired"
+        when :loading then "Loading"
+        when :scanned then "Scanned"
+        else "Active"
         end
+        t_default(key, default: default)
       end
 
+      sig { returns(T.nilable(String)) }
       def status_description
         case @status
         when :expired
-          "Please refresh to continue"
+          t_default("description.expired", default: "Please refresh to continue")
         when :scanned
-          "You can now continue"
+          t_default("description.scanned", default: "You can now continue")
         else
           nil
         end
@@ -158,21 +202,23 @@ module HakumiComponents
 
       private
 
+      sig { void }
       def validate_props!
         validate_required!(:value)
         validate_inclusion!(:type, TYPES)
         validate_inclusion!(:status, STATUSES)
         validate_inclusion!(:error_level, ERROR_LEVELS)
 
-        if @size.nil? || @size.to_f <= 0
+        if @size.to_f <= 0
           raise ArgumentError, "size must be a positive number"
         end
 
-        if icon? && (@icon_size.nil? || @icon_size.to_f <= 0)
+        if icon? && @icon_size.to_f <= 0
           raise ArgumentError, "icon_size must be a positive number"
         end
       end
 
+      sig { returns(String) }
       def wrapper_classes
         modifiers = {
           @type => true,
@@ -182,9 +228,10 @@ module HakumiComponents
           "custom-status" => custom_status_render?
         }
 
-        class_names("qr-code", modifiers, [ @html_options[:class] ])
+        component_classes("qr-code", modifiers, @html_options)
       end
 
+      sig { returns(String) }
       def wrapper_styles
         styles = {
           "--hakumi-qr-code-size" => size_css_value,
@@ -196,27 +243,24 @@ module HakumiComponents
         styles.compact.map { |key, value| "#{key}: #{value}" }.join("; ")
       end
 
+      sig { returns(String) }
       def size_css_value
-        return nil unless @size
-
-        value = @size.to_f
-        value = value.to_i if value == value.to_i
-        "#{value}px"
+        "#{formatted_number(@size)}px"
       end
 
+      sig { returns(T.nilable(String)) }
       def icon_css_value
         return nil unless icon?
 
-        value = @icon_size.to_f
-        value = value.to_i if value == value.to_i
-        "#{value}px"
+        "#{formatted_number(@icon_size)}px"
       end
 
+      sig { void }
       def resolve_icon!
-        @icon_component = nil
-        @icon_url = nil
+        @icon_component = T.let(nil, IconRenderable)
+        @icon_url = T.let(nil, T.nilable(String))
 
-        if @icon_input.respond_to?(:render_in)
+        if @icon_input.is_a?(ViewComponent::Base) || @icon_input.is_a?(ViewComponent::Slot)
           @icon_component = @icon_input
           return
         end
@@ -235,16 +279,19 @@ module HakumiComponents
         @icon_component = HakumiComponents::Icon::Component.new(name: icon_name, size: icon_component_size)
       end
 
+      sig { returns(T::Boolean) }
       def icon_component?
-        @icon_component.present?
+        !@icon_component.nil?
       end
 
+      sig { returns(T::Boolean) }
       def icon_image?
         @icon_url.present?
       end
 
+      sig { returns(Types::DataAttributes) }
       def data_attributes
-        data = {
+        data = T.let({
           controller: "hakumi--qr-code",
           "hakumi--qr-code-value-value": @value,
           "hakumi--qr-code-size-value": @size,
@@ -253,34 +300,40 @@ module HakumiComponents
           "hakumi--qr-code-bg-color-value": @bg_color,
           "hakumi--qr-code-error-level-value": @error_level,
           "hakumi--qr-code-status-value": @status
-        }
+        }, Types::DataAttributes)
 
         data["hakumi--qr-code-download-name-value"] = @download_name if @download_name.present?
         data
       end
 
+      sig { returns(T::Boolean) }
       def loading?
         @status == :loading
       end
 
+      sig { returns(T::Boolean) }
       def custom_status_render?
         @status_render.present?
       end
 
+      sig { returns(Types::RenderedContent) }
       def custom_status_overlay
         return unless custom_status_render?
 
-        if @status_render.respond_to?(:call)
+        if @status_render.is_a?(Proc)
           return view_context.capture { @status_render.call(@status) }
         end
 
-        return render(@status_render) if @status_render.respond_to?(:render_in)
+        if @status_render.is_a?(ViewComponent::Base) || @status_render.is_a?(ViewComponent::Slot)
+          return render(@status_render)
+        end
 
         @status_render
       end
 
+      sig { returns(ActiveSupport::SafeBuffer) }
       def default_status_overlay
-        content = []
+        content = T.let([], T::Array[Types::RenderedContent])
         if loading?
           content << render(HakumiComponents::Spin::Component.new(size: :small))
         end
@@ -295,6 +348,7 @@ module HakumiComponents
         end
       end
 
+      sig { params(value: OptionInput).returns(T.nilable(Symbol)) }
       def normalize_symbol(value)
         return nil if value.nil?
 
@@ -305,11 +359,13 @@ module HakumiComponents
         raw.to_sym
       end
 
+      sig { params(value: OptionInput).returns(T.nilable(Symbol)) }
       def normalize_error_level(value)
         symbol = normalize_symbol(value)
         symbol&.to_s&.upcase&.to_sym
       end
 
+      sig { params(value: T.nilable(Types::ValidationComparable)).returns(T.nilable(String)) }
       def normalize_string(value)
         return nil if value.nil?
 
@@ -317,6 +373,7 @@ module HakumiComponents
         raw.empty? ? nil : raw
       end
 
+      sig { params(value: IconInput).returns(T.nilable(Symbol)) }
       def extract_icon_name(value)
         case value
         when Symbol
@@ -330,10 +387,19 @@ module HakumiComponents
         end
       end
 
+      sig { returns(Integer) }
       def icon_component_size
         size = (@icon_size.to_f * 0.65).round
         size.positive? ? size : 24
       end
+
+      sig { params(value: NumberValue).returns(NumberValue) }
+      def formatted_number(value)
+        return value if value.is_a?(Integer)
+
+        remainder = value % 1
+        remainder.zero? ? value.to_i : value
+      end
     end
   end
 end

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

@@ -2,15 +2,15 @@
   <label class="<%= wrapper_classes %>" data-controller="<%= data_controllers %>" data-hakumi--radio-checked-value="<%= @checked %>" data-hakumi--radio-variant-value="default">
     <span class="<%= radio_classes %>" data-hakumi--radio-target="radio">
       <%= radio_button_tag(
-            @name,
+            form_field_name,
             @value,
             @checked,
             id: input_id,
             disabled: @disabled,
             autofocus: @auto_focus,
-            required: @required,
+            required: form_field_required,
             class: "hakumi-radio-input",
-            "aria-invalid": has_error? ? "true" : nil,
+            "aria-invalid": error? ? "true" : nil,
             "aria-describedby": describedby_ids,
             data: (@html_options[:data] || {}).merge({
               hakumi__radio_target: "input",

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

@@ -1,12 +1,31 @@
+# typed: strict
 # frozen_string_literal: true
 
 module HakumiComponents
   module Radio
     class Component < HakumiComponents::BaseComponent
-      include HakumiComponents::Concerns::FormField
+      extend T::Sig
 
-      SIZES = [ :small, :middle, :large ].freeze
+      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,
@@ -15,7 +34,7 @@ module HakumiComponents
         caption: nil,
         checked: false,
         disabled: false,
-        size: :middle,
+        size: :default,
         id: nil,
         auto_focus: false,
         required: false,
@@ -24,54 +43,68 @@ module HakumiComponents
         **html_options
       )
         @name = name
-        @value = value
+        @value = T.let(value, HakumiComponents::Types::FormFieldScalar)
         @text = text
         @label = label
         @caption = caption
         @checked = checked
         @disabled = disabled
         @size = size
-        @id = id || generate_id("radio")
+        @id = T.let(id || generate_id("radio"), Types::FormFieldName)
         @auto_focus = auto_focus
         @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)
         @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 != :middle
+        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 != :middle
+        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

data/app/components/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 HakumiComponents::Radio::Component.new(
-              name: @name,
-              value: option[:value],
-              checked: option_checked?(option[:value]),
+              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 %>