hakumi_components 0.1.18.pre → 0.1.19.pre

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

@@ -1,29 +1,55 @@
+# typed: strict
 # frozen_string_literal: true
 
 module HakumiComponents
   module Segmented
     class Component < HakumiComponents::BaseComponent
-      SIZES = [ :small, :middle, :large ].freeze
+      extend T::Sig
 
+      sig do
+        params(
+          params: T.any(ActionController::Parameters, Types::HtmlAttributes)
+        ).returns(Types::HtmlAttributes)
+      end
       def self.extract_controller_locals(params)
-        options = params[:options]
-        options = params[:options_json] if options.nil?
-        options = parse_options_param(options)
+        options = html_param(params, :options)
+        options = html_param(params, :options_json) if options.nil?
+
+        normalized_options = if options.is_a?(String) || options.is_a?(Array)
+          HakumiComponents::Segmented::Option.coerce_all(options)
+        else
+          nil
+        end
 
         {
-          options: options,
-          value: params[:value],
-          default_value: params[:default_value],
-          disabled: truthy_param?(params[:disabled]),
-          block: truthy_param?(params[:block]),
-          vertical: truthy_param?(params[:vertical]),
-          round: truthy_param?(params[:round]),
-          name: params[:name],
-          size: params[:size],
-          aria_label: params[:aria_label]
+          options: normalized_options,
+          value: html_param(params, :value),
+          default_value: html_param(params, :default_value),
+          disabled: boolean_html_param(html_param(params, :disabled)),
+          block: boolean_html_param(html_param(params, :block)),
+          vertical: boolean_html_param(html_param(params, :vertical)),
+          round: boolean_html_param(html_param(params, :round)),
+          name: string_html_param(html_param(params, :name)),
+          size: symbol_html_param(html_param(params, :size)),
+          aria_label: string_html_param(html_param(params, :aria_label))
         }.compact
       end
 
+      sig do
+        params(
+          options: T.any(String, T::Array[T.any(Types::FormFieldScalar, Types::HtmlAttributes)]),
+          value: Types::FormFieldScalar,
+          default_value: Types::FormFieldScalar,
+          disabled: T::Boolean,
+          block: T::Boolean,
+          vertical: T::Boolean,
+          round: T::Boolean,
+          name: T.nilable(String),
+          size: Symbol,
+          aria_label: T.nilable(String),
+          html_options: Types::HtmlAttributeValue
+        ).void
+      end
       def initialize(
         options: [],
         value: nil,
@@ -33,25 +59,26 @@ module HakumiComponents
         vertical: false,
         round: false,
         name: nil,
-        size: :middle,
+        size: :default,
         aria_label: nil,
         **html_options
       )
-        @options = normalize_options(options)
-        @value = normalize_value(value, default_value)
-        @value = @options.first[:value]&.to_s if @value.nil? && @options.any?
-        @disabled = cast_boolean(disabled)
-        @block = cast_boolean(block)
-        @vertical = cast_boolean(vertical)
-        @round = cast_boolean(round)
-        @name = normalize_string(name) || generate_id("segmented")
-        @size = normalize_size(size) || :middle
-        @aria_label = normalize_string(aria_label)
-        @html_options = html_options
+        @options = T.let(HakumiComponents::Segmented::Option.coerce_all(options), T::Array[HakumiComponents::Segmented::Option])
+        @value = T.let(normalize_value(value, default_value), T.nilable(String))
+        @value = T.let(@options.first&.string_value, T.nilable(String)) if @value.nil? && @options.any?
+        @disabled = T.let(disabled, T::Boolean)
+        @block = T.let(block, T::Boolean)
+        @vertical = T.let(vertical, T::Boolean)
+        @round = T.let(round, T::Boolean)
+        @name = T.let(name.presence || generate_id("segmented"), String)
+        @size = T.let(size, Symbol)
+        @aria_label = T.let(aria_label, T.nilable(String))
+        @html_options = T.let(html_options, Types::HtmlAttributes)
 
         validate_props!
       end
 
+      sig { returns(Types::HtmlAttributes) }
       def wrapper_attributes
         attrs = {
           class: wrapper_classes,
@@ -65,10 +92,12 @@ module HakumiComponents
         merge_attributes(attrs, @html_options.except(:class))
       end
 
+      sig { returns(T::Array[HakumiComponents::Segmented::Option]) }
       def normalized_options
         @options
       end
 
+      sig { params(option: HakumiComponents::Segmented::Option).returns(String) }
       def option_classes(option)
         class_names(
           "segmented-item",
@@ -77,21 +106,23 @@ module HakumiComponents
             disabled: option_disabled?(option)
           },
           [
-            option[:class_name],
-            ("hakumi-segmented-item-icon-only" if icon_only_option?(option))
+            option.class_name,
+            ("hakumi-segmented-item-icon-only" if option.icon_only?)
           ]
         )
       end
 
+      sig { params(option: HakumiComponents::Segmented::Option).returns(Types::DataAttributes) }
       def option_data_attributes(option)
         {
           "hakumi--segmented-target": "item",
-          value: option[:value].to_s,
-          label: option[:label].is_a?(String) ? option[:label] : nil,
+          value: option.string_value,
+          label: option.label.is_a?(String) ? option.label : nil,
           disabled: option_disabled?(option) ? "true" : nil
         }.compact
       end
 
+      sig { params(option: HakumiComponents::Segmented::Option, index: Integer).returns(Types::HtmlAttributes) }
       def option_input_attributes(option, index)
         attrs = {
           id: option_id(index),
@@ -109,22 +140,26 @@ module HakumiComponents
         attrs
       end
 
+      sig { params(option: HakumiComponents::Segmented::Option).returns(T::Boolean) }
       def option_selected?(option)
         return false if @value.nil?
 
-        option[:value].to_s == @value.to_s
+        option.string_value == @value.to_s
       end
 
+      sig { params(option: HakumiComponents::Segmented::Option).returns(T::Boolean) }
       def option_disabled?(option)
-        @disabled || option[:disabled]
+        @disabled || option.disabled
       end
 
+      sig { params(index: Integer).returns(String) }
       def option_id(index)
         "#{@name}_#{index}"
       end
 
+      sig { params(option: HakumiComponents::Segmented::Option).returns(T.nilable(String)) }
       def option_label(option)
-        label = option[:label]
+        label = option.label
         return nil if label.nil?
         return label if label.is_a?(String)
         return render(label) if label.respond_to?(:render_in)
@@ -132,8 +167,9 @@ module HakumiComponents
         label.to_s
       end
 
+      sig { params(option: HakumiComponents::Segmented::Option).returns(T.nilable(Types::RenderedContent)) }
       def option_icon(option)
-        icon = option[:icon]
+        icon = option.icon
         return nil if icon.nil?
 
         if icon.is_a?(String) || icon.is_a?(Symbol)
@@ -141,16 +177,18 @@ module HakumiComponents
         elsif icon.respond_to?(:render_in)
           render(icon)
         else
-          icon
+          nil
         end
       end
 
       private
 
+      sig { void }
       def validate_props!
         validate_inclusion!(:size, SIZES)
       end
 
+      sig { returns(String) }
       def wrapper_classes
         modifiers = {
           block: @block,
@@ -159,64 +197,23 @@ module HakumiComponents
           disabled: @disabled
         }
 
-        modifiers[@size] = true if @size != :middle
+        modifiers[@size] = true if @size != :default
 
-        class_names("segmented", modifiers, [ @html_options[:class] ])
-      end
-
-      def normalize_options(options)
-        Array(options).map.with_index do |option, index|
-          if option.is_a?(Hash)
-            label_key_present = option.key?(:label) || option.key?("label")
-            value_key_present = option.key?(:value) || option.key?("value")
-            label_value = if label_key_present
-                            option[:label] || option["label"]
-            else
-                            option[:value] || option["value"] || "Option #{index + 1}"
-            end
-            value_value = if value_key_present
-                            option[:value] || option["value"]
-            else
-                            label_value
-            end
-
-            {
-              label: label_value,
-              value: value_value,
-              disabled: cast_boolean(option[:disabled] || option["disabled"]),
-              icon: option[:icon] || option["icon"],
-              class_name: option[:class_name] || option["class_name"],
-              aria_label: option[:aria_label] || option["aria_label"]
-            }
-          else
-            {
-              label: option,
-              value: option,
-              disabled: false,
-              icon: nil,
-              class_name: nil,
-              aria_label: nil
-            }
-          end
-        end
+        class_names("segmented", modifiers, html_classes(@html_options))
       end
 
+      sig { params(option: HakumiComponents::Segmented::Option).returns(T.nilable(String)) }
       def option_aria_label(option)
-        return option[:aria_label] if option[:aria_label].present?
+        return option.aria_label if option.aria_label.present?
 
-        label = option[:label]
+        label = option.label
         return strip_tags(label.to_s) if label.is_a?(String)
-        return option[:value].to_s if option[:value].present?
+        return option.string_value if option.value.present?
 
         nil
       end
 
-      def icon_only_option?(option)
-        icon = option[:icon]
-        label = option[:label]
-        icon.present? && (label.nil? || (label.respond_to?(:empty?) && label.empty?))
-      end
-
+      sig { returns(Types::DataAttributes) }
       def data_attributes
         {
           controller: "hakumi--segmented",
@@ -225,45 +222,11 @@ module HakumiComponents
         }.compact
       end
 
+      sig { params(value: Types::FormFieldScalar, default_value: Types::FormFieldScalar).returns(T.nilable(String)) }
       def normalize_value(value, default_value)
         raw = value.nil? ? default_value : value
         raw.nil? ? nil : raw.to_s
       end
-
-      def normalize_size(size)
-        val = size.is_a?(String) ? size.strip : size
-        symbol = val.presence&.to_sym
-        symbol == :default ? :middle : symbol
-      end
-
-      def normalize_string(value)
-        return nil if value.nil?
-
-        value = value.to_s.strip
-        value.presence
-      end
-
-      def self.parse_options_param(options)
-        return options if options.is_a?(Array)
-        return nil if options.nil?
-
-        if options.is_a?(String)
-          begin
-            parsed = JSON.parse(options)
-            return parsed
-          rescue JSON::ParserError
-            return options.split(",")
-          end
-        end
-
-        options
-      end
-
-      def self.truthy_param?(value)
-        return value if value == true || value == false
-
-        value.to_s == "true"
-      end
     end
   end
 end

data/app/components/hakumi_components/segmented/option.rb

@@ -0,0 +1,191 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Segmented
+    class Option
+      extend T::Sig
+
+      IconValue = T.type_alias { T.nilable(T.any(String, Symbol, ViewComponent::Base, ViewComponent::Slot)) }
+      JsonValue = T.type_alias { T.nilable(T.any(String, Numeric, T::Boolean, T::Array[T.untyped], T::Hash[String, T.untyped])) }
+      ParsedEntry = T.type_alias { T.any(HakumiComponents::Segmented::Option, HakumiComponents::Types::FormFieldScalar, Types::HtmlAttributes) }
+
+      sig do
+        params(
+          label: T.nilable(Types::Renderable),
+          value: Types::FormFieldScalar,
+          disabled: T::Boolean,
+          icon: IconValue,
+          class_name: T.nilable(String),
+          aria_label: T.nilable(String)
+        ).void
+      end
+      def initialize(label:, value:, disabled: false, icon: nil, class_name: nil, aria_label: nil)
+        @label = T.let(label, T.nilable(Types::Renderable))
+        @value = T.let(value, Types::FormFieldScalar)
+        @disabled = T.let(disabled, T::Boolean)
+        @icon = T.let(icon, IconValue)
+        @class_name = T.let(class_name, T.nilable(String))
+        @aria_label = T.let(aria_label, T.nilable(String))
+      end
+
+      sig { returns(T.nilable(Types::Renderable)) }
+      attr_reader :label
+
+      sig { returns(Types::FormFieldScalar) }
+      attr_reader :value
+
+      sig { returns(T::Boolean) }
+      attr_reader :disabled
+
+      sig { returns(IconValue) }
+      attr_reader :icon
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :class_name, :aria_label
+
+      sig { returns(String) }
+      def string_value
+        @value.to_s
+      end
+
+      sig { returns(T::Boolean) }
+      def icon_only?
+        @icon.present? && (@label.nil? || (@label.is_a?(String) && @label.empty?))
+      end
+
+      sig { params(options: T.any(String, T::Array[ParsedEntry], T.nilable(T::Array[ParsedEntry]))).returns(T::Array[HakumiComponents::Segmented::Option]) }
+      def self.coerce_all(options)
+        source = parse_options(options)
+        coerced = T.let([], T::Array[HakumiComponents::Segmented::Option])
+        Array(source).each_with_index do |option, index|
+          coerced << coerce(option, index)
+        end
+        coerced
+      end
+
+      sig { params(option: ParsedEntry, index: Integer).returns(HakumiComponents::Segmented::Option) }
+      def self.coerce(option, index)
+        return option if option.is_a?(HakumiComponents::Segmented::Option)
+
+        if option.is_a?(Hash)
+          label_value = extract_label(option, index)
+          value_value = extract_value(option, label_value)
+
+          return new(
+            label: label_value,
+            value: value_value,
+            disabled: HakumiComponents::BaseComponent.boolean_html_param(option[:disabled]) == true,
+            icon: coerce_icon(option[:icon]),
+            class_name: coerce_string(option[:class_name]),
+            aria_label: coerce_string(option[:aria_label])
+          )
+        end
+
+        new(label: option&.to_s, value: option, disabled: false)
+      end
+
+      class << self
+        extend T::Sig
+
+        private
+
+        sig { params(options: T.any(String, T::Array[ParsedEntry], T.nilable(T::Array[ParsedEntry]))).returns(T.nilable(T::Array[ParsedEntry])) }
+        def parse_options(options)
+          return options if options.is_a?(Array)
+          return nil if options.nil?
+
+          if options.is_a?(String)
+            begin
+              parsed = JSON.parse(options)
+              return parse_json_array(parsed) if parsed.is_a?(Array)
+            rescue JSON::ParserError
+              return options.split(",")
+            end
+          end
+
+          nil
+        end
+
+        sig { params(parsed: T::Array[JsonValue]).returns(T::Array[ParsedEntry]) }
+        def parse_json_array(parsed)
+          entries = T.let([], T::Array[ParsedEntry])
+          parsed.each do |entry|
+            if entry.is_a?(Hash)
+              attrs = T.let({}, Types::HtmlAttributes)
+              entry.each do |key, value|
+                next unless key.is_a?(String)
+
+                symbol_key = key.to_sym
+                attrs[symbol_key] = coerce_html_value(value)
+              end
+              entries << attrs
+            elsif entry.is_a?(String) || entry.is_a?(Numeric) || entry == true || entry == false
+              entries << entry
+            end
+          end
+          entries
+        end
+
+        sig { params(option: Types::HtmlAttributes, index: Integer).returns(T.nilable(Types::Renderable)) }
+        def extract_label(option, index)
+          if option.key?(:label)
+            coerce_label(option[:label])
+          else
+            coerce_label(option[:value] || "Option #{index + 1}")
+          end
+        end
+
+        sig { params(option: Types::HtmlAttributes, label_value: T.nilable(Types::Renderable)).returns(Types::FormFieldScalar) }
+        def extract_value(option, label_value)
+          if option.key?(:value)
+            raw = option[:value]
+            return raw if raw.nil? || raw.is_a?(String) || raw.is_a?(Symbol) || raw.is_a?(TrueClass) || raw.is_a?(FalseClass) || raw.is_a?(Numeric) || raw.is_a?(Date) || raw.is_a?(Time) || raw.is_a?(DateTime) || raw.is_a?(ActiveSupport::TimeWithZone)
+
+            raise ArgumentError, "segmented option value must be scalar"
+          end
+
+          return label_value if label_value.nil? || label_value.is_a?(String)
+
+          raise ArgumentError, "segmented option value must be scalar"
+        end
+
+        sig { params(value: Types::HtmlAttributeValue).returns(T.nilable(String)) }
+        def coerce_label(value)
+          return value if value.is_a?(String)
+          return nil if value.nil?
+          return value.to_s if scalar_value?(value)
+
+          nil
+        end
+
+        sig { params(value: Types::HtmlAttributeValue).returns(IconValue) }
+        def coerce_icon(value)
+          return value if value.is_a?(String)
+          return value if value.is_a?(Symbol)
+
+          nil
+        end
+
+        sig { params(value: Types::HtmlAttributeValue).returns(T.nilable(String)) }
+        def coerce_string(value)
+          return value if value.is_a?(String)
+
+          nil
+        end
+
+        sig { params(value: JsonValue).returns(Types::HtmlAttributeValue) }
+        def coerce_html_value(value)
+          return value if value.is_a?(String) || value.is_a?(Symbol) || value.is_a?(Numeric) || value == true || value == false
+
+          nil
+        end
+
+        sig { params(value: Types::HtmlAttributeValue).returns(T::Boolean) }
+        def scalar_value?(value)
+          value.nil? || value.is_a?(String) || value.is_a?(Symbol) || value.is_a?(TrueClass) || value.is_a?(FalseClass) || value.is_a?(Numeric)
+        end
+      end
+    end
+  end
+end

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

@@ -1,12 +1,12 @@
 <% select_control = capture do %>
   <div <%= tag.attributes(wrapper_attributes) %>>
     <input type="hidden"
-           name="<%= @name %>"
+           name="<%= form_field_name %>"
            id="<%= input_id %>"
-           value="<%= @value %>"
+           value="<%= selection_control_value %>"
            data-hakumi--select-target="input"
-           <%= 'required' if @required %>
-           <%= "aria-invalid=#{has_error?}" if has_error? %>
+           <%= 'required' if form_field_required %>
+           <%= "aria-invalid=#{error?}" if error? %>
            <%= "aria-describedby=#{describedby_ids}" if describedby_ids %>>
 
     <% if borderless? %>
@@ -23,13 +23,13 @@
                    data-hakumi--select-target="searchInput"
                    data-action="input->hakumi--select#onSearchInput keydown->hakumi--select#onSearchKeydown"
                    autocomplete="off"
-                   placeholder="<%= @placeholder %>"
+                   placeholder="<%= selection_control_placeholder %>"
                    value="<%= selected_label || '' %>"
                    role="combobox"
                    aria-haspopup="listbox"
-                   aria-owns="<%= @name %>_list"
+                   aria-owns="<%= list_id %>"
                    aria-autocomplete="list"
-                   aria-controls="<%= @name %>_list"
+                   aria-controls="<%= list_id %>"
                    aria-activedescendant="">
           </span>
         <% else %>
@@ -39,20 +39,20 @@
             <span class="hakumi-select-selection-item" data-hakumi--select-target="label" style="display: none;"></span>
           <% end %>
 
-          <% if @placeholder %>
+          <% if selection_control_placeholder %>
             <span class="hakumi-select-selection-placeholder"
                   data-hakumi--select-target="placeholder"
                   style="<%= selected_label ? 'display: none;' : '' %>">
-              <%= @placeholder %>
+              <%= selection_control_placeholder %>
             </span>
           <% end %>
         <% end %>
       </div>
 
-      <% if @allow_clear %>
+      <% if selection_control_allow_clear %>
         <span class="hakumi-select-clear"
               data-action="click->hakumi--select#clear"
-              style="<%= @value.present? ? '' : 'display: none;' %>"
+              style="<%= selection_control_has_value? ? '' : 'display: none;' %>"
               data-hakumi--select-target="clearBtn">
           <%= render HakumiComponents::Icon::Component.new(name: :close_circle, theme: :filled) %>
         </span>
@@ -64,16 +64,16 @@
     <% end %>
 
     <div class="hakumi-select-dropdown hakumi-select-dropdown-hidden" data-hakumi--select-target="dropdown">
-      <div class="rc-virtual-list-holder-inner" role="listbox" id="<%= @name %>_list">
-        <% formatted_options.each do |label, value| %>
-          <div class="hakumi-select-item hakumi-select-item-option <%= 'hakumi-select-item-option-selected' if value.to_s == @value.to_s %>"
+      <div class="rc-virtual-list-holder-inner" role="listbox" id="<%= list_id %>">
+        <% normalized_options.each do |option| %>
+          <div class="hakumi-select-item hakumi-select-item-option <%= 'hakumi-select-item-option-selected' if option.value.to_s == selection_control_value.to_s %>"
                role="option"
-               aria-selected="<%= value.to_s == @value.to_s %>"
-               data-value="<%= value %>"
-               data-label="<%= label %>"
+               aria-selected="<%= option.value.to_s == selection_control_value.to_s %>"
+               data-value="<%= option.value %>"
+               data-label="<%= option.label %>"
                data-action="click->hakumi--select#select"
                data-hakumi--select-target="option">
-            <div class="hakumi-select-item-option-content"><%= label %></div>
+            <div class="hakumi-select-item-option-content"><%= option.label %></div>
           </div>
         <% end %>
         <div class="hakumi-select-item-empty" data-hakumi--select-target="empty" style="display: none;">
@@ -84,7 +84,7 @@
   </div>
 <% end %>
 
-<% if @standalone %>
+<% if standalone? %>
   <%= select_control %>
 <% else %>
   <div <%= tag.attributes(form_item_attributes).to_s.html_safe %>>