hakumi_components 0.1.18.pre → 0.1.19.pre

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

@@ -1,118 +1,167 @@
+# typed: strict
 # frozen_string_literal: true
 
 module HakumiComponents
   module Cascader
-    # Public API
-    #
-    # ```erb
-    # <%= render HakumiComponents::Cascader::Component.new(
-    #       options: [
-    #         { value: "spain", label: "Spain", children: [
-    #             { value: "madrid", label: "Madrid", children: [
-    #                 { value: "salamanca", label: "Salamanca" }
-    #               ] }
-    #           ]
-    #         },
-    #         { value: "france", label: "France", children: [
-    #             { value: "paris", label: "Paris", children: [
-    #                 { value: "montmartre", label: "Montmartre" }
-    #               ] }
-    #           ]
-    #         }
-    #       ],
-    #       value: ["spain", "madrid", "salamanca"],
-    #       placeholder: "Select a city",
-    #       trigger: :click,
-    #       change_on_select: false,
-    #       allow_clear: true
-    #     ) %>
-    # ```
-    #
-    # Options:
-    # - `options` (`Array<Hash>`, default: `[]`): tree of nodes (`value`, `label`, optional `children`).
-    # - `value` (`Array`, default: `[]`): pre-selected value path.
-    # - `placeholder` (`String`, default: `"Select"`).
-    # - `size` (`:small`, `:middle`, `:large`, default: `:middle`).
-    # - `disabled` (`Boolean`, default: `false`).
-    # - `allow_clear` (`Boolean`, default: `true`).
-    # - `show_search` (`Boolean`, default: `false`).
-    # - `change_on_select` (`Boolean`, default: `false`).
-    # - `expand_trigger` (`:click`, `:hover`, default: `:click`).
-    # - `display_render` (callable, optional) for custom label rendering.
-    # - Additional `html_options` are merged into the wrapper div.
     class Component < HakumiComponents::BaseComponent
-      SIZES = [ :small, :middle, :large ].freeze
-      TRIGGERS = [ :click, :hover ].freeze
+      extend T::Sig
 
+      include HakumiComponents::Concerns::SelectionControl
+
+      TRIGGERS = T.let([ :click, :hover ].freeze, T::Array[Symbol])
+
+      sig do
+        params(
+          name: T.nilable(Types::FormFieldName),
+          options: T.nilable(T::Array[HakumiComponents::SelectionControl::TreeNode::Input]),
+          label: T.nilable(String),
+          caption: T.nilable(String),
+          value: Types::FormFieldValue,
+          placeholder: T.nilable(String),
+          size: Symbol,
+          disabled: T::Boolean,
+          required: T::Boolean,
+          allow_clear: T::Boolean,
+          show_search: T::Boolean,
+          change_on_select: T::Boolean,
+          expand_trigger: Symbol,
+          display_render: T.nilable(T.proc.params(labels: T::Array[String]).returns(String)),
+          standalone: T::Boolean,
+          rules: T.nilable(T::Array[Types::ValidationRule]),
+          errors: Types::FormFieldErrors,
+          html_options: Types::HtmlAttributeValue
+        ).void
+      end
       def initialize(
         name: nil,
         options: [],
+        label: nil,
+        caption: nil,
         value: [],
-        placeholder: "Select",
-        size: :middle,
+        placeholder: nil,
+        size: :default,
         disabled: false,
+        required: false,
         allow_clear: true,
         show_search: false,
         change_on_select: false,
         expand_trigger: :click,
         display_render: nil,
+        standalone: true,
+        rules: nil,
+        errors: [],
         **html_options
       )
-        @name = name || generate_id("cascader")
-        @options = options
-        @value = value || []
-        @placeholder = placeholder
+        @name = T.let(name || generate_id("cascader"), Types::FormFieldName)
+        @options = T.let(
+          HakumiComponents::SelectionControl::Coercion.tree_nodes(Array(options)),
+          T::Array[HakumiComponents::SelectionControl::TreeNode]
+        )
+        @label = label
+        @caption = caption
+        @value = T.let(value || [], Types::FormFieldValue)
+        @placeholder = T.let(placeholder || t_default(:placeholder, default: "Select"), T.nilable(String))
         @size = size
         @disabled = disabled
+        @required = required
         @allow_clear = allow_clear
         @show_search = show_search
         @change_on_select = change_on_select
         @expand_trigger = expand_trigger
-        @display_render = display_render
-        @html_options = html_options
+        @display_render = T.let(display_render, T.nilable(T.proc.params(labels: T::Array[String]).returns(String)))
+        @standalone = standalone
+        @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_selection_control_contract!(
+          name: @name,
+          label: @label,
+          caption: @caption,
+          value: @value,
+          placeholder: @placeholder,
+          size: @size,
+          disabled: @disabled,
+          allow_clear: @allow_clear,
+          required: @required,
+          standalone: @standalone,
+          errors: @errors,
+          html_options: @html_options,
+          rules: @rules
+        )
 
         validate_props!
       end
 
+      sig { void }
       def validate_props!
         validate_inclusion!(:size, SIZES)
         validate_inclusion!(:expand_trigger, TRIGGERS)
       end
 
+      sig { returns(String) }
       def wrapper_classes
         class_names(
           "cascader",
           {
-            lg: @size == :large,
-            sm: @size == :small,
-            disabled: @disabled,
-            "allow-clear": @allow_clear
+            lg: selection_control_size == :large,
+            sm: selection_control_size == :small,
+            disabled: selection_control_disabled,
+            "allow-clear": selection_control_allow_clear
           },
-          @html_options[:class]
+          [ selection_control_html_class_name ]
         )
       end
 
+      sig { returns(Types::HtmlAttributes) }
       def wrapper_attributes
         base_attrs = {
           class: wrapper_classes,
           data: {
             controller: "hakumi--cascader",
-            hakumi__cascader_options_value: @options.to_json,
-            hakumi__cascader_value_value: @value.to_json,
+            hakumi__cascader_options_value: normalized_options.map(&:to_cascader_option).to_json,
+            hakumi__cascader_value_value: Array(selection_control_value).to_json,
             hakumi__cascader_trigger_value: @expand_trigger,
             hakumi__cascader_change_on_select_value: @change_on_select,
-            hakumi__cascader_disabled_value: @disabled
+            hakumi__cascader_disabled_value: selection_control_disabled
           }
         }
-        merge_attributes(base_attrs, @html_options.except(:class))
+        merge_attributes(base_attrs, selection_control_html_options_without_class)
       end
 
+      sig { returns(T.nilable(String)) }
       def selected_label
-        # Logic to find labels for the current @value path
-        # Simplistic implementation: this will likely be handled by JS for dynamic updates
-        # But for SSR, we should try to render it if possible.
-        # For complex implementation, let's rely on Stimulus to populate on connect if value exists.
-        nil
+        labels = labels_for_path(Array(selection_control_value))
+        return nil if labels.empty?
+
+        return @display_render.call(labels) if @display_render
+
+        labels.join(" / ")
+      end
+
+      private
+
+      sig { returns(T::Array[HakumiComponents::SelectionControl::TreeNode]) }
+      attr_reader :options
+
+      sig { returns(T::Array[HakumiComponents::SelectionControl::TreeNode]) }
+      def normalized_options
+        options
+      end
+
+      sig { params(path: T::Array[HakumiComponents::Types::FormFieldScalar]).returns(T::Array[String]) }
+      def labels_for_path(path)
+        labels = T.let([], T::Array[String])
+        current_nodes = normalized_options
+
+        path.each do |segment|
+          current_node = current_nodes.find { |node| node.string_value == segment.to_s }
+          break if current_node.nil?
+
+          labels << current_node.label
+          current_nodes = current_node.children
+        end
+
+        labels
       end
     end
   end

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

@@ -2,10 +2,10 @@
   <label id="<%= @wrapper_id %>" class="<%= wrapper_classes %>" data-controller="<%= data_controllers %>" data-hakumi--checkbox-checked-value="<%= @checked %>" data-hakumi--checkbox-indeterminate-value="<%= @indeterminate %>">
     <span class="<%= checkbox_classes %>" data-hakumi--checkbox-target="checkbox">
       <%= check_box_tag(
-            @name,
+            form_field_name,
             @value,
             @checked,
-            id: @id,
+            id: input_id,
             disabled: @disabled,
             class: "hakumi-checkbox-input",
             data: {
@@ -16,8 +16,8 @@
           ) %>
       <span class="hakumi-checkbox-inner"></span>
     </span>
-    <% if @label.present? || content.present? %>
-      <span><%= @label || content %></span>
+    <% if form_field_label.present? || content.present? %>
+      <span><%= form_field_label || content %></span>
     <% end %>
   </label>
 <% end %>
@@ -26,7 +26,7 @@
   <%= checkbox_control %>
 <% else %>
   <div <%= tag.attributes(form_item_attributes).to_s.html_safe %>>
-    <%= render_label(field_id: @id) %>
+    <%= render_label(field_id: input_id) %>
 
     <div class="hakumi-form-item-control">
       <div class="hakumi-form-item-control-input">

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

@@ -1,10 +1,31 @@
+# typed: strict
 # frozen_string_literal: true
 
 module HakumiComponents
   module Checkbox
     class Component < HakumiComponents::BaseComponent
+      extend T::Sig
+
       include HakumiComponents::Concerns::FormField
 
+      sig do
+        params(
+          checked: T::Boolean,
+          disabled: T::Boolean,
+          indeterminate: T::Boolean,
+          value: HakumiComponents::Types::FormFieldScalar,
+          name: T.nilable(Types::FormFieldName),
+          id: T.nilable(Types::FormFieldName),
+          wrapper_id: T.nilable(String),
+          auto_focus: T::Boolean,
+          label: T.nilable(String),
+          caption: T.nilable(String),
+          standalone: T::Boolean,
+          required: T::Boolean,
+          errors: Types::FormFieldErrors,
+          html_options: Types::HtmlAttributeValue
+        ).void
+      end
       def initialize(
         checked: false,
         disabled: false,
@@ -12,6 +33,7 @@ module HakumiComponents
         value: nil,
         name: nil,
         id: nil,
+        wrapper_id: nil,
         auto_focus: false,
         label: nil,
         caption: nil,
@@ -23,19 +45,29 @@ module HakumiComponents
         @checked = checked
         @disabled = disabled
         @indeterminate = indeterminate
-        @value = value || "1"
-        @name = name
-        @id = id || generate_id("checkbox")
+        @value = T.let(value || "1", HakumiComponents::Types::FormFieldScalar)
+        @name = T.let(name || generate_id("checkbox"), Types::FormFieldName)
+        @id = T.let(id || generate_id("checkbox"), Types::FormFieldName)
         @auto_focus = auto_focus
         @label = label
         @caption = caption
         @standalone = standalone
         @required = required
-        @errors = Array(errors)
-        @wrapper_id = html_options.delete(:id) || generate_id("hakumi-checkbox")
-        @html_options = html_options
+        @errors = T.let(errors, Types::FormFieldErrors)
+        @wrapper_id = T.let(wrapper_id || "#{@id}-wrapper", String)
+        @html_options = T.let(html_options.merge(id: @id), 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(String) }
       def wrapper_classes
         class_names(
           "checkbox-wrapper",
@@ -45,6 +77,7 @@ module HakumiComponents
         )
       end
 
+      sig { returns(String) }
       def checkbox_classes
         class_names(
           "checkbox",
@@ -56,6 +89,7 @@ module HakumiComponents
         )
       end
 
+      sig { returns(String) }
       def data_controllers
         "hakumi--checkbox"
       end

data/app/components/hakumi_components/checkbox/group/component.html.erb

@@ -2,10 +2,10 @@
   <% normalized_options.each do |option| %>
     <%= render HakumiComponents::Checkbox::Component.new(
           name: "#{@name}[]",
-          value: option[:value],
-          checked: option_checked?(option[:value]),
-          disabled: @disabled || option[:disabled],
-          label: option[:label]
+          value: option.value,
+          checked: option_checked?(option.value),
+          disabled: @disabled || option.disabled,
+          label: option.label
         ) %>
   <% end %>
   <%= content %>

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

@@ -1,9 +1,22 @@
+# typed: strict
 # frozen_string_literal: true
 
 module HakumiComponents
   module Checkbox
     module Group
       class Component < HakumiComponents::BaseComponent
+        extend T::Sig
+
+        sig do
+          params(
+            name: T.nilable(HakumiComponents::Types::FormFieldName),
+            value: T::Array[HakumiComponents::Types::FormFieldScalar],
+            default_value: T::Array[HakumiComponents::Types::FormFieldScalar],
+            options: T::Array[T.any(String, HakumiComponents::Checkbox::Group::Option)],
+            disabled: T::Boolean,
+            html_options: HakumiComponents::Types::HtmlAttributeValue
+          ).void
+        end
         def initialize(
           name: nil,
           value: [],
@@ -12,52 +25,66 @@ module HakumiComponents
           disabled: false,
           **html_options
         )
-          @name = name || generate_id("checkbox_group")
-          @value = value.presence || default_value || []
-          @options = options
-          @disabled = disabled
-          @html_options = html_options
+          @name = T.let(name || generate_id("checkbox_group"), HakumiComponents::Types::FormFieldName)
+          @value = T.let(value.empty? ? default_value : value, T::Array[HakumiComponents::Types::FormFieldScalar])
+          @options = T.let(options, T::Array[T.any(String, HakumiComponents::Checkbox::Group::Option)])
+          @disabled = T.let(disabled, T::Boolean)
+          @html_options = T.let(html_options, HakumiComponents::Types::HtmlAttributes)
         end
 
+        sig { returns(String) }
         def wrapper_classes
           class_names("checkbox-group")
         end
 
+        sig { returns(HakumiComponents::Types::HtmlAttributes) }
         def wrapper_attributes
           merged = merge_attributes(
             {
               class: wrapper_classes,
               role: "group"
             },
-            @html_options
+            @html_options.except(:data)
           )
 
-          data = merged[:data] ||= {}
-
-          existing_controller = data[:controller] || data["controller"]
+          data = existing_data_attributes
+          existing_controller = data[:controller]
           controllers = existing_controller.to_s.split(/\s+/).reject(&:blank?)
           controllers << "hakumi--checkbox-group"
           data[:controller] = controllers.uniq.join(" ")
+          data[:"hakumi--checkbox-group-value-value"] ||= @value.map(&:to_s).to_json
 
-          data_key = "hakumi--checkbox-group-value-value"
-          data[data_key] ||= @value.map(&:to_s).to_json
-
+          merged[:data] = data
           merged
         end
 
+        sig { returns(T::Array[HakumiComponents::Checkbox::Group::Option]) }
         def normalized_options
           @options.map do |option|
             if option.is_a?(String)
-              { label: option, value: option }
+              HakumiComponents::Checkbox::Group::Option.new(label: option, value: option)
             else
               option
             end
           end
         end
 
+        sig { params(option_value: HakumiComponents::Types::FormFieldScalar).returns(T::Boolean) }
         def option_checked?(option_value)
           @value.include?(option_value.to_s) || @value.include?(option_value)
         end
+
+        private
+
+        sig { returns(HakumiComponents::Types::DataAttributes) }
+        def existing_data_attributes
+          value = @html_options[:data]
+          return {} unless value.is_a?(Hash)
+
+          data = T.let({}, HakumiComponents::Types::DataAttributes)
+          value.each { |key, entry| data[key] = entry }
+          data
+        end
       end
     end
   end

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

@@ -0,0 +1,34 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Checkbox
+    module Group
+      class Option
+        extend T::Sig
+
+        sig do
+          params(
+            label: String,
+            value: HakumiComponents::Types::FormFieldScalar,
+            disabled: T::Boolean
+          ).void
+        end
+        def initialize(label:, value:, disabled: false)
+          @label = label
+          @value = value
+          @disabled = disabled
+        end
+
+        sig { returns(String) }
+        attr_reader :label
+
+        sig { returns(HakumiComponents::Types::FormFieldScalar) }
+        attr_reader :value
+
+        sig { returns(T::Boolean) }
+        attr_reader :disabled
+      end
+    end
+  end
+end

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

@@ -1,10 +1,12 @@
+# typed: strict
 # frozen_string_literal: true
 
 module HakumiComponents
   module Collapse
     class Component < HakumiComponents::BaseComponent
-      SIZES = %i[default small large].freeze
-      COLLAPSIBLES = [ nil, :header, :icon, :disabled ].freeze
+      extend T::Sig
+
+      COLLAPSIBLES = T.let([ nil, :header, :icon, :disabled ].freeze, T::Array[T.nilable(Symbol)])
 
       renders_many :panels, ->(
         key:,
@@ -14,9 +16,9 @@ module HakumiComponents
         show_arrow: true,
         collapsible: nil,
         force_render: false,
-        **options,
         &block
       ) do
+        T.bind(self, HakumiComponents::Collapse::Component)
         item = HakumiComponents::Collapse::Panel::Component.new(
           key: key,
           header: header,
@@ -25,13 +27,24 @@ module HakumiComponents
           show_arrow: show_arrow,
           collapsible: collapsible,
           force_render: force_render,
-          parent: self,
-          **options
+          parent: self
         )
         item.content = capture(&block) if block
         item
       end
 
+      sig do
+        params(
+          size: Symbol,
+          accordion: T::Boolean,
+          bordered: T::Boolean,
+          ghost: T::Boolean,
+          collapsible: T.nilable(Symbol),
+          active_keys: T.nilable(T.any(String, Integer, T::Array[T.any(String, Integer)])),
+          default_active_keys: T.nilable(T.any(String, Integer, T::Array[T.any(String, Integer)])),
+          html_options: Types::HtmlAttributeValue
+        ).void
+      end
       def initialize(
         size: :default,
         accordion: false,
@@ -42,72 +55,75 @@ module HakumiComponents
         default_active_keys: nil,
         **html_options
       )
-        @size = size
-        @accordion = accordion
-        @bordered = bordered
-        @ghost = ghost
-        @collapsible = collapsible
-        @active_keys = normalize_keys(active_keys)
-        @default_active_keys = normalize_keys(default_active_keys)
-        @html_options = html_options
+        @size = T.let(size, Symbol)
+        @accordion = T.let(accordion, T::Boolean)
+        @bordered = T.let(bordered, T::Boolean)
+        @ghost = T.let(ghost, T::Boolean)
+        @collapsible = T.let(collapsible, T.nilable(Symbol))
+        @active_keys = T.let(normalize_keys(active_keys), T.nilable(T::Array[String]))
+        @default_active_keys = T.let(normalize_keys(default_active_keys), T.nilable(T::Array[String]))
+        @html_options = T.let(html_options, Types::HtmlAttributes)
 
         validate_props!
       end
 
-      attr_reader :size, :accordion, :bordered, :ghost, :collapsible
+      private
 
-      def collapse_classes
-        classes = [ "hakumi-collapse" ]
-        classes << "hakumi-collapse-small" if @size == :small
-        classes << "hakumi-collapse-large" if @size == :large
-        classes << "hakumi-collapse-borderless" unless @bordered
-        classes << "hakumi-collapse-ghost" if @ghost
-        classes << @html_options[:class] if @html_options[:class]
-        classes.compact.join(" ")
-      end
+      sig { returns(Symbol) }
+      attr_reader :size
 
-      def wrapper_attributes
-        base_attrs = {
-          class: collapse_classes,
-          data: {
-            controller: stimulus_controller
-          }.merge(stimulus_data_attributes)
-        }
-        merge_attributes(base_attrs, @html_options.except(:class))
-      end
+      sig { returns(T::Boolean) }
+      attr_reader :accordion, :bordered, :ghost
 
-      def stimulus_controller
-        "hakumi--collapse"
-      end
+      sig { returns(T.nilable(Symbol)) }
+      attr_reader :collapsible
 
+      sig { returns(T::Array[String]) }
       def initial_active_keys
         @active_keys || @default_active_keys || []
       end
 
-      def stimulus_values
-        {
+      sig { returns(String) }
+      def collapse_classes
+        component_classes(
+          "collapse",
+          {
+            small: @size == :small,
+            large: @size == :large,
+            borderless: !@bordered,
+            ghost: @ghost
+          },
+          @html_options
+        )
+      end
+
+      sig { returns(Types::HtmlAttributes) }
+      def wrapper_attributes
+        data = stimulus_attrs("hakumi--collapse", T.let({
           accordion: @accordion,
           active_keys: initial_active_keys,
-          collapsible: (@collapsible&.to_s),
+          collapsible: @collapsible&.to_s,
           bordered: @bordered,
           ghost: @ghost
-        }
+        }, Types::StimulusValues))
+        merge_attributes({ class: collapse_classes, data: data }, @html_options.except(:class))
       end
 
-      def stimulus_data_attributes
-        stimulus_values.each_with_object({}) do |(k, v), h|
-          h["#{stimulus_controller}-#{k.to_s.dasherize}-value"] = v.is_a?(Array) ? v.to_json : v
-        end
+      sig do
+        params(value: T.nilable(T.any(String, Integer, T::Array[T.any(String, Integer)]))).returns(T.nilable(T::Array[String]))
       end
-
-      private
-
       def normalize_keys(value)
         return nil if value.nil?
-        arr = value.is_a?(Array) ? value : [ value ]
-        arr.compact.map(&:to_s)
+
+        arr = if value.is_a?(Array)
+          value
+        else
+          [ value ]
+        end
+        arr.map(&:to_s)
       end
 
+      sig { void }
       def validate_props!
         validate_inclusion!(:size, SIZES)
         validate_inclusion!(:collapsible, COLLAPSIBLES)