hakumi_components 0.1.18.pre → 0.1.19.pre

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

@@ -1,27 +1,48 @@
+# typed: strict
 # frozen_string_literal: true
 
 module HakumiComponents
   module InputNumber
-    # Hakumi InputNumber component
-    # Numeric input with precision, formatter, and spinner controls
-    #
-    # @example Basic usage
-    #   <%= render HakumiComponents::InputNumber::Component.new(name: :amount, value: 10) %>
-    #
-    # @example With formatter and prefix
-    #   <%= render HakumiComponents::InputNumber::Component.new(
-    #     name: :price,
-    #     value: 199.95,
-    #     prefix: "$",
-    #     formatter: { style: "currency", currency: "USD", minimumFractionDigits: 2 }
-    #   ) %>
     class Component < HakumiComponents::BaseComponent
-      include HakumiComponents::Concerns::FormField
+      extend T::Sig
 
-      SIZES = [ :small, :middle, :large ].freeze
-      VARIANTS = [ :default, :filled, :borderless ].freeze
-      STATUSES = [ :default, :success, :warning, :error ].freeze
+      include HakumiComponents::Concerns::InputControl
 
+      NumericLike = T.type_alias { T.any(String, Numeric) }
+      FormatterOptions = T.type_alias { T::Hash[Symbol, T.nilable(T.any(String, Symbol, T::Boolean, Numeric))] }
+
+      VARIANTS = T.let([ :default, :filled, :borderless ].freeze, T::Array[Symbol])
+      STATUSES = T.let([ :default, :success, :warning, :error ].freeze, T::Array[Symbol])
+
+      sig do
+        params(
+          name: Types::FormFieldName,
+          label: T.nilable(String),
+          caption: T.nilable(String),
+          value: Types::FormFieldValue,
+          placeholder: T.nilable(String),
+          min: T.nilable(NumericLike),
+          max: T.nilable(NumericLike),
+          step: NumericLike,
+          precision: T.nilable(NumericLike),
+          size: Symbol,
+          variant: Symbol,
+          status: Symbol,
+          disabled: T::Boolean,
+          readonly: T::Boolean,
+          required: T::Boolean,
+          prefix: Types::Renderable,
+          suffix: Types::Renderable,
+          controls: T::Boolean,
+          keyboard: T::Boolean,
+          wheel: T::Boolean,
+          formatter: T.nilable(FormatterOptions),
+          standalone: T::Boolean,
+          rules: T.nilable(T::Array[Types::ValidationRule]),
+          errors: Types::FormFieldErrors,
+          html_options: Types::HtmlAttributeValue
+        ).void
+      end
       def initialize(
         name:,
         label: nil,
@@ -32,7 +53,7 @@ module HakumiComponents
         max: nil,
         step: 1,
         precision: nil,
-        size: :middle,
+        size: :default,
         variant: :default,
         status: :default,
         disabled: false,
@@ -47,16 +68,16 @@ module HakumiComponents
         standalone: true,
         rules: nil,
         errors: [],
-        **html_attrs
+        **html_options
       )
-        @name = name
+        @name = T.let(name, Types::FormFieldName)
         @label = label
         @caption = caption
         @value = value
         @placeholder = placeholder
         @min = min
         @max = max
-        @step = step
+        @step = T.let(step, NumericLike)
         @precision = precision
         @size = size
         @variant = variant
@@ -69,54 +90,70 @@ module HakumiComponents
         @controls = controls
         @keyboard = keyboard
         @wheel = wheel
-        @formatter = formatter
+        @formatter = T.let(formatter, T.nilable(FormatterOptions))
         @standalone = standalone
-        @rules = rules
-        @errors = Array(errors)
-        @html_attrs = html_attrs
+        @rules = T.let(rules, T.nilable(T::Array[Types::ValidationRule]))
+        @errors = T.let(errors, Types::FormFieldErrors)
+        @html_options = T.let(html_options, Types::HtmlAttributes)
+        initialize_input_control_contract!(
+          name: @name,
+          label: @label,
+          caption: @caption,
+          value: @value,
+          placeholder: @placeholder,
+          size: @size,
+          disabled: @disabled,
+          readonly: @readonly,
+          errors: @errors,
+          standalone: @standalone,
+          required: @required,
+          html_options: @html_options,
+          rules: @rules
+        )
 
         validate_props!
       end
 
       private
 
+      sig { void }
       def validate_props!
         validate_inclusion!(:size, SIZES)
         validate_inclusion!(:variant, VARIANTS)
         validate_inclusion!(:status, STATUSES)
         validate_numeric_like!(@step, "step")
-        validate_numeric_like!(@min, "min") if @min
-        validate_numeric_like!(@max, "max") if @max
-        validate_numeric_like!(@precision, "precision") if @precision
-
-        return if @formatter.nil? || @formatter.is_a?(Hash)
-
-        raise ArgumentError, "formatter must be a Hash of Intl.NumberFormat options"
+        validate_numeric_like!(@min, "min")
+        validate_numeric_like!(@max, "max")
+        validate_numeric_like!(@precision, "precision")
       end
 
+      sig { params(value: T.nilable(NumericLike), name: String).void }
       def validate_numeric_like!(value, name)
+        return if value.nil?
         return if value.is_a?(Numeric) || value.is_a?(String)
 
         raise ArgumentError, "#{name} must be a number or string"
       end
 
+      sig { returns(String) }
       def component_html_class
         class_names(
           "input-number",
           {
-            @size => @size != :middle,
+            input_control_size => input_control_size != :default,
             @variant => @variant != :default,
-            disabled: @disabled,
-            readonly: @readonly,
+            disabled: input_control_disabled,
+            readonly: input_control_readonly,
             "no-controls": !@controls,
-            "has-prefix": @prefix.present?,
-            "has-suffix": @suffix.present?,
+            "has-prefix": value_present?(@prefix),
+            "has-suffix": value_present?(@suffix),
             status: @status != :default ? @status : nil
           },
-          @html_attrs[:wrapper_class]
+          [ wrapper_class_name ]
         )
       end
 
+      sig { returns(Types::HtmlAttributes) }
       def wrapper_attributes
         merge_attributes(
           {
@@ -129,70 +166,115 @@ module HakumiComponents
               hakumi__input_number_precision_value: @precision,
               hakumi__input_number_keyboard_value: @keyboard,
               hakumi__input_number_wheel_value: @wheel,
-              hakumi__input_number_disabled_value: @disabled,
+              hakumi__input_number_disabled_value: input_control_disabled,
               hakumi__input_number_formatter_options_value: formatter_options_json
             }.compact
           },
           {
-            id: @html_attrs[:id],
-            data: @html_attrs[:data]
+            id: input_id,
+            data: html_data_attributes
           }.compact
         )
       end
 
+      sig { returns(String) }
       def input_classes
-        class_names("input-number-input", {}, @html_attrs[:class])
+        class_names("input-number-input", {}, [ html_class_name ])
       end
 
+      sig { returns(Types::HtmlAttributes) }
       def input_attributes
         merge_attributes(
           {
             type: "text",
             inputmode: "decimal",
-            name: @name,
+            name: form_field_name,
             id: input_id,
-            value: @value,
-            placeholder: @placeholder,
+            value: input_control_value,
+            placeholder: input_control_placeholder,
             class: input_classes,
-            disabled: @disabled ? true : nil,
-            readonly: @readonly ? true : nil,
+            disabled: input_control_disabled ? true : nil,
+            readonly: input_control_readonly ? true : nil,
             autocomplete: "off",
             role: "spinbutton",
-            "aria-invalid": has_error? ? "true" : nil,
+            "aria-invalid": error? ? "true" : nil,
             "aria-describedby": describedby_ids,
             "aria-valuemin": @min,
             "aria-valuemax": @max,
-            "aria-valuenow": @value,
+            "aria-valuenow": input_control_value,
             data: {
               action: "input->hakumi--input-number#handleInput focus->hakumi--input-number#handleFocus blur->hakumi--input-number#handleBlur keydown->hakumi--input-number#handleKeydown wheel->hakumi--input-number#handleWheel",
               hakumi__input_number_target: "input"
             }
           }.compact,
-          @html_attrs.except(:id, :wrapper_class)
+          form_field_html_options.except(:id, :wrapper_class)
         )
       end
 
+      sig { returns(T.nilable(ActiveSupport::SafeBuffer)) }
       def prefix_element
-        return nil unless @prefix.present?
+        prefix_content = render_adornment_content(@prefix)
+        return nil if prefix_content.nil?
 
-        content_tag(:span, render_value(@prefix), class: "hakumi-input-number-prefix")
+        content_tag(:span, prefix_content, class: "hakumi-input-number-prefix")
       end
 
+      sig { returns(T.nilable(ActiveSupport::SafeBuffer)) }
       def suffix_element
-        return nil unless @suffix.present?
+        suffix_content = render_adornment_content(@suffix)
+        return nil if suffix_content.nil?
 
-        content_tag(:span, render_value(@suffix), class: "hakumi-input-number-suffix")
+        content_tag(:span, suffix_content, class: "hakumi-input-number-suffix")
       end
 
+      sig { returns(T::Boolean) }
       def controls?
         @controls
       end
 
+      sig { returns(T.nilable(String)) }
       def formatter_options_json
-        return nil unless @formatter.present?
+        return nil if @formatter.nil? || @formatter.empty?
 
         @formatter.to_json
       end
+
+      sig { params(value: Types::Renderable).returns(T.nilable(T.any(String, ActiveSupport::SafeBuffer))) }
+      def render_adornment_content(value)
+        return nil unless value_present?(value)
+        return value if value.is_a?(ActiveSupport::SafeBuffer) || value.is_a?(String)
+        return render(value).to_s if value.is_a?(ViewComponent::Base)
+
+        nil
+      end
+
+      sig { returns(Types::DataAttributes) }
+      def html_data_attributes
+        data_attributes = T.let({}, Types::DataAttributes)
+        html_data = form_field_html_options[:data]
+        return data_attributes unless html_data.is_a?(Hash)
+
+        html_data.each do |key, value|
+          next unless key.is_a?(String) || key.is_a?(Symbol)
+          next unless value.nil? || value.is_a?(String) || value.is_a?(Symbol) || value.is_a?(TrueClass) || value.is_a?(FalseClass) || value.is_a?(Numeric)
+
+          data_attributes[key] = value
+        end
+
+        data_attributes
+      end
+
+      sig { returns(T.nilable(String)) }
+      def html_class_name
+        css_class = form_field_html_options[:class]
+        css_class.is_a?(String) ? css_class : nil
+      end
+
+      sig { returns(T.nilable(String)) }
+      def wrapper_class_name
+        wrapper_class = form_field_html_options[:wrapper_class]
+        wrapper_class.is_a?(String) ? wrapper_class : nil
+      end
     end
   end
 end

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

@@ -1 +1 @@
-<section <%= tag.attributes(html_attributes) %>><%= content %></section>
+<%= content_tag :section, content, wrapper_attributes %>

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

@@ -1,21 +1,28 @@
-class HakumiComponents::Layout::Component < HakumiComponents::BaseComponent
-  def initialize(has_sider: false, **html_options)
-    @has_sider = has_sider
-    @html_options = html_options
-  end
+# typed: strict
+# frozen_string_literal: true
 
-  private
+module HakumiComponents
+  module Layout
+    class Component < BaseComponent
+      extend T::Sig
 
-  def html_attributes
-    attrs = @html_options.dup
-    attrs[:class] = css_classes
-    attrs
-  end
+      sig { params(has_sider: T::Boolean, html_options: Types::HtmlAttributeValue).void }
+      def initialize(has_sider: false, **html_options)
+        @has_sider = T.let(has_sider, T::Boolean)
+        @html_options = T.let(html_options, Types::HtmlAttributes)
+      end
+
+      private
+
+      sig { returns(String) }
+      def wrapper_classes
+        component_classes("layout", { "has-sider": @has_sider }, @html_options)
+      end
 
-  def css_classes
-    classes = [ "hakumi-layout" ]
-    classes << "hakumi-layout-has-sider" if @has_sider
-    classes << @html_options[:class] if @html_options[:class]
-    classes.join(" ")
+      sig { returns(Types::HtmlAttributes) }
+      def wrapper_attributes
+        merge_attributes({ class: wrapper_classes }, @html_options.except(:class))
+      end
+    end
   end
 end

data/app/components/hakumi_components/layout/content/component.html.erb

@@ -1 +1 @@
-<main <%= tag.attributes(html_attributes) %>><%= content %></main>
+<%= content_tag :main, content, wrapper_attributes %>

data/app/components/hakumi_components/layout/content/component.rb

@@ -1,19 +1,29 @@
-class HakumiComponents::Layout::Content::Component < HakumiComponents::BaseComponent
-  def initialize(**html_options)
-    @html_options = html_options
-  end
+# typed: strict
+# frozen_string_literal: true
 
-  private
+module HakumiComponents
+  module Layout
+    module Content
+      class Component < BaseComponent
+        extend T::Sig
 
-  def html_attributes
-    attrs = @html_options.dup
-    attrs[:class] = css_classes
-    attrs
-  end
+        sig { params(html_options: Types::HtmlAttributeValue).void }
+        def initialize(**html_options)
+          @html_options = T.let(html_options, Types::HtmlAttributes)
+        end
+
+        private
+
+        sig { returns(String) }
+        def wrapper_classes
+          component_classes("layout-content", {}, @html_options)
+        end
 
-  def css_classes
-    classes = [ "hakumi-layout-content" ]
-    classes << @html_options[:class] if @html_options[:class]
-    classes.join(" ")
+        sig { returns(Types::HtmlAttributes) }
+        def wrapper_attributes
+          merge_attributes({ class: wrapper_classes }, @html_options.except(:class))
+        end
+      end
+    end
   end
 end

data/app/components/hakumi_components/layout/footer/component.html.erb

@@ -1 +1 @@
-<footer <%= tag.attributes(html_attributes) %>><%= content %></footer>
+<%= content_tag :footer, content, wrapper_attributes %>

data/app/components/hakumi_components/layout/footer/component.rb

@@ -1,19 +1,29 @@
-class HakumiComponents::Layout::Footer::Component < HakumiComponents::BaseComponent
-  def initialize(**html_options)
-    @html_options = html_options
-  end
+# typed: strict
+# frozen_string_literal: true
 
-  private
+module HakumiComponents
+  module Layout
+    module Footer
+      class Component < BaseComponent
+        extend T::Sig
 
-  def html_attributes
-    attrs = @html_options.dup
-    attrs[:class] = css_classes
-    attrs
-  end
+        sig { params(html_options: Types::HtmlAttributeValue).void }
+        def initialize(**html_options)
+          @html_options = T.let(html_options, Types::HtmlAttributes)
+        end
+
+        private
+
+        sig { returns(String) }
+        def wrapper_classes
+          component_classes("layout-footer", {}, @html_options)
+        end
 
-  def css_classes
-    classes = [ "hakumi-layout-footer" ]
-    classes << @html_options[:class] if @html_options[:class]
-    classes.join(" ")
+        sig { returns(Types::HtmlAttributes) }
+        def wrapper_attributes
+          merge_attributes({ class: wrapper_classes }, @html_options.except(:class))
+        end
+      end
+    end
   end
 end

data/app/components/hakumi_components/layout/header/component.html.erb

@@ -1 +1 @@
-<header <%= tag.attributes(html_attributes) %>><%= content %></header>
+<%= content_tag :header, content, wrapper_attributes %>

data/app/components/hakumi_components/layout/header/component.rb

@@ -1,19 +1,29 @@
-class HakumiComponents::Layout::Header::Component < HakumiComponents::BaseComponent
-  def initialize(**html_options)
-    @html_options = html_options
-  end
+# typed: strict
+# frozen_string_literal: true
 
-  private
+module HakumiComponents
+  module Layout
+    module Header
+      class Component < BaseComponent
+        extend T::Sig
 
-  def html_attributes
-    attrs = @html_options.dup
-    attrs[:class] = css_classes
-    attrs
-  end
+        sig { params(html_options: Types::HtmlAttributeValue).void }
+        def initialize(**html_options)
+          @html_options = T.let(html_options, Types::HtmlAttributes)
+        end
+
+        private
+
+        sig { returns(String) }
+        def wrapper_classes
+          component_classes("layout-header", {}, @html_options)
+        end
 
-  def css_classes
-    classes = [ "hakumi-layout-header" ]
-    classes << @html_options[:class] if @html_options[:class]
-    classes.join(" ")
+        sig { returns(Types::HtmlAttributes) }
+        def wrapper_attributes
+          merge_attributes({ class: wrapper_classes }, @html_options.except(:class))
+        end
+      end
+    end
   end
 end

data/app/components/hakumi_components/layout/sider/component.html.erb

@@ -1 +1 @@
-<aside <%= tag.attributes(html_attributes) %>><%= content %></aside>
+<%= content_tag :aside, content, wrapper_attributes %>

data/app/components/hakumi_components/layout/sider/component.rb

@@ -1,56 +1,90 @@
-class HakumiComponents::Layout::Sider::Component < HakumiComponents::BaseComponent
-  def initialize(
-    width: 200,
-    collapsed_width: 80,
-    collapsible: false,
-    collapsed: false,
-    theme: :dark,
-    breakpoint: nil,
-    **html_options
-  )
-    @width = width
-    @collapsed_width = collapsed_width
-    @collapsible = collapsible
-    @collapsed = collapsed
-    @theme = theme
-    @breakpoint = breakpoint
-    @html_options = html_options
-  end
+# typed: strict
+# frozen_string_literal: true
 
-  private
+module HakumiComponents
+  module Layout
+    module Sider
+      class Component < BaseComponent
+        extend T::Sig
+        THEMES = T.let(%i[dark light].freeze, T::Array[Symbol])
+        BREAKPOINTS = T.let(%i[xs sm md lg xl].freeze, T::Array[Symbol])
 
-  def html_attributes
-    attrs = @html_options.dup
-    attrs[:class] = css_classes
-    attrs[:style] = inline_styles
-    attrs
-  end
+        sig do
+          params(
+            width: Integer,
+            collapsed_width: Integer,
+            collapsible: T::Boolean,
+            collapsed: T::Boolean,
+            theme: Symbol,
+            breakpoint: T.nilable(Symbol),
+            html_options: Types::HtmlAttributeValue
+          ).void
+        end
+        def initialize(
+          width: 200,
+          collapsed_width: 80,
+          collapsible: false,
+          collapsed: false,
+          theme: :dark,
+          breakpoint: nil,
+          **html_options
+        )
+          @width = T.let(width, Integer)
+          @collapsed_width = T.let(collapsed_width, Integer)
+          @collapsible = T.let(collapsible, T::Boolean)
+          @collapsed = T.let(collapsed, T::Boolean)
+          @theme = T.let(theme, Symbol)
+          @breakpoint = T.let(breakpoint, T.nilable(Symbol))
+          @html_options = T.let(html_options, Types::HtmlAttributes)
 
-  def css_classes
-    classes = [ "hakumi-layout-sider" ]
-    classes << "hakumi-layout-sider-dark" if @theme.to_sym == :dark
-    classes << "hakumi-layout-sider-light" if @theme.to_sym == :light
-    classes << "hakumi-layout-sider-collapsed" if @collapsed
-    classes << "hakumi-layout-sider-has-trigger" if @collapsible
-    classes << @html_options[:class] if @html_options[:class]
-    classes.join(" ")
-  end
+          validate_props!
+        end
+
+        private
+
+        sig { void }
+        def validate_props!
+          validate_inclusion!(:theme, THEMES)
+          validate_inclusion!(:breakpoint, BREAKPOINTS) if @breakpoint
+        end
+
+        sig { returns(String) }
+        def wrapper_classes
+          modifiers = T.let({
+            dark: @theme == :dark,
+            light: @theme == :light,
+            collapsed: @collapsed,
+            "has-trigger": @collapsible
+          }, Types::ClassModifiers)
+          modifiers[@breakpoint] = true if @breakpoint
+
+          component_classes("layout-sider", modifiers, @html_options)
+        end
+
+        sig { returns(Types::HtmlAttributes) }
+        def wrapper_attributes
+          merge_attributes(
+            { class: wrapper_classes, style: inline_styles },
+            @html_options.except(:class, :style)
+          )
+        end
+
+        sig { returns(String) }
+        def inline_styles
+          active_width = @collapsed ? @collapsed_width : @width
+          styles = T.let([
+            "flex: 0 0 #{active_width}px",
+            "max-width: #{active_width}px",
+            "min-width: #{active_width}px",
+            "width: #{active_width}px"
+          ], T::Array[String])
+
+          existing_style = html_style(@html_options)
+          styles << existing_style if existing_style
 
-  def inline_styles
-    styles = []
-    if @collapsed
-      styles << "flex: 0 0 #{@collapsed_width}px"
-      styles << "max-width: #{@collapsed_width}px"
-      styles << "min-width: #{@collapsed_width}px"
-      styles << "width: #{@collapsed_width}px"
-    else
-      styles << "flex: 0 0 #{@width}px"
-      styles << "max-width: #{@width}px"
-      styles << "min-width: #{@width}px"
-      styles << "width: #{@width}px"
+          styles.join("; ")
+        end
+      end
     end
-    combined_styles = styles.join("; ")
-    combined_styles += "; #{@html_options[:style]}" if @html_options[:style]
-    combined_styles
   end
 end