hakumi_components 0.1.18.pre → 0.1.19.pre

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

@@ -1,16 +1,38 @@
+# typed: strict
 # frozen_string_literal: true
 
 module HakumiComponents
   module Select
-    # Hakumi Select component
-    # A custom selector component that mimics Ant Design React behavior
     class Component < HakumiComponents::BaseComponent
-      include HakumiComponents::Concerns::FormField
+      extend T::Sig
 
-      SIZES = [ :small, :middle, :large ].freeze
-      VARIANTS = [ :default, :borderless ].freeze
-      TRIGGERS = [ :click, :hover ].freeze
+      include HakumiComponents::Concerns::SelectionControl
 
+      VARIANTS = T.let([ :default, :borderless ].freeze, T::Array[Symbol])
+      TRIGGERS = T.let([ :click, :hover ].freeze, T::Array[Symbol])
+
+      sig do
+        params(
+          name: T.nilable(Types::FormFieldName),
+          options: T.nilable(T::Array[HakumiComponents::SelectionControl::Coercion::FlatOptionInput]),
+          label: T.nilable(String),
+          caption: T.nilable(String),
+          value: Types::FormFieldValue,
+          placeholder: T.nilable(String),
+          size: Symbol,
+          variant: Symbol,
+          trigger: Symbol,
+          icon: T.nilable(Types::StringOrSymbol),
+          disabled: T::Boolean,
+          required: T::Boolean,
+          allow_clear: T::Boolean,
+          show_search: T::Boolean,
+          standalone: T::Boolean,
+          rules: T.nilable(T::Array[Types::ValidationRule]),
+          errors: Types::FormFieldErrors,
+          html_options: Types::HtmlAttributeValue
+        ).void
+      end
       def initialize(
         name: nil,
         options: [],
@@ -18,7 +40,7 @@ module HakumiComponents
         caption: nil,
         value: nil,
         placeholder: nil,
-        size: :middle,
+        size: :default,
         variant: :default,
         trigger: :click,
         icon: nil,
@@ -27,14 +49,15 @@ module HakumiComponents
         allow_clear: false,
         show_search: false,
         standalone: true,
+        rules: nil,
         errors: [],
         **html_options
       )
-        @name = name || generate_id("select")
-        @options = options
+        @name = T.let(name || generate_id("select"), Types::FormFieldName)
+        @options = T.let(HakumiComponents::SelectionControl::Coercion.options(Array(options)), T::Array[HakumiComponents::SelectionControl::Option])
         @label = label
         @caption = caption
-        @value = value
+        @value = T.let(value, Types::FormFieldValue)
         @placeholder = placeholder
         @size = size
         @variant = variant
@@ -45,80 +68,108 @@ module HakumiComponents
         @allow_clear = allow_clear
         @show_search = show_search
         @standalone = standalone
-        @errors = Array(errors)
-        @html_options = html_options
+        @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,
+          errors: @errors,
+          standalone: @standalone,
+          required: @required,
+          html_options: @html_options,
+          rules: @rules
+        )
 
         validate_props!
       end
 
-      attr_reader :variant, :trigger, :icon
+      sig { returns(Symbol) }
+      attr_reader :variant
+
+      sig { returns(Symbol) }
+      attr_reader :trigger
+
+      sig { returns(T.nilable(Types::StringOrSymbol)) }
+      attr_reader :icon
 
       private
 
+      sig { returns(T::Array[HakumiComponents::SelectionControl::Option]) }
+      attr_reader :options
+
+      sig { void }
       def validate_props!
         validate_inclusion!(:size, SIZES)
         validate_inclusion!(:variant, VARIANTS)
         validate_inclusion!(:trigger, TRIGGERS)
       end
 
+      sig { returns(String) }
       def select_wrapper_classes
         class_names(
           "select",
           {
-            lg: @size == :large,
-            sm: @size == :small,
+            lg: selection_control_size == :large,
+            sm: selection_control_size == :small,
             borderless: @variant == :borderless,
             "hover-trigger": @trigger == :hover,
-            disabled: @disabled,
+            disabled: selection_control_disabled,
             "show-search": @show_search,
-            "allow-clear": @allow_clear,
-            "has-value": @value.present?
+            "allow-clear": selection_control_allow_clear,
+            "has-value": selection_control_has_value?
           },
-          [ @html_options[:class] ]
+          [ selection_control_html_class_name ]
         )
       end
 
+      sig { returns(T::Boolean) }
       def borderless?
         @variant == :borderless
       end
 
+      sig { returns(T::Boolean) }
       def hover_trigger?
         @trigger == :hover
       end
 
+      sig { returns(Types::HtmlAttributes) }
       def wrapper_attributes
         base_attrs = {
           class: select_wrapper_classes,
           data: {
             controller: "hakumi--select",
-            hakumi__select_allow_clear_value: @allow_clear ? "true" : "false",
-            hakumi__select_disabled_value: @disabled ? "true" : "false",
+            hakumi__select_allow_clear_value: selection_control_allow_clear,
+            hakumi__select_disabled_value: selection_control_disabled,
             hakumi__select_trigger_value: @trigger.to_s
           }
         }
 
-        # Merge html_options but exclude :class since it's already in select_wrapper_classes
-        extra_options = @html_options.except(:class)
-        merge_attributes(base_attrs, extra_options)
+        merge_attributes(base_attrs, selection_control_html_options_without_class)
       end
 
-      # Returns the label for the currently selected value
+      sig { returns(T.nilable(String)) }
       def selected_label
-        return nil if @value.blank?
+        return nil unless selection_control_has_value?
+
+        option = options.find { |item| item.value.to_s == selection_control_value.to_s }
+        option ? option.label : selection_control_value.to_s
+      end
 
-        option = @options.find { |opt| opt[1].to_s == @value.to_s }
-        option ? option[0] : @value
+      sig { returns(String) }
+      def list_id
+        "#{form_field_name}_list"
       end
 
-      # Ensures options are in [label, value] format
-      def formatted_options
-        @options.map do |opt|
-          if opt.is_a?(Array)
-            [ opt[0], opt[1] ]
-          else
-            [ opt, opt ]
-          end
-        end
+      sig { returns(T::Array[HakumiComponents::SelectionControl::Option]) }
+      def normalized_options
+        options
       end
     end
   end

data/app/components/hakumi_components/selection_control/coercion.rb

@@ -0,0 +1,161 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module SelectionControl
+    module Coercion
+      extend T::Sig
+      extend self
+
+      FlatOptionHash = T.type_alias { T::Hash[Types::HtmlKey, T.nilable(Types::ValidationPrimitive)] }
+      FlatOptionTuple = T.type_alias { [ T.nilable(Types::ValidationPrimitive), T.nilable(Types::ValidationPrimitive) ] }
+      FlatOptionInput = T.type_alias do
+        T.any(
+          Option,
+          FlatOptionHash,
+          FlatOptionTuple,
+          HakumiComponents::Types::FormFieldScalar
+        )
+      end
+      GroupEntryHash = T.type_alias do
+        T::Hash[
+          Types::HtmlKey,
+          T.nilable(
+            T.any(
+              Types::ValidationComparable,
+              T::Array[FlatOptionInput]
+            )
+          )
+        ]
+      end
+      EntryInput = T.type_alias { T.any(Entry, FlatOptionInput, GroupEntryHash) }
+      TreeNodeInput = T.type_alias { HakumiComponents::SelectionControl::TreeNode::Input }
+      ScalarInput = T.type_alias do
+        T.nilable(T.any(Types::FormFieldScalar, Date, Time, DateTime, ActiveSupport::TimeWithZone, ActiveSupport::SafeBuffer))
+      end
+
+      sig do
+        params(
+          value: ScalarInput,
+          fallback: ScalarInput
+        ).returns(HakumiComponents::Types::FormFieldScalar)
+      end
+      def scalar(value, fallback:)
+        value.nil? ? fallback : value
+      end
+
+      sig { params(options: T::Array[FlatOptionInput]).returns(T::Array[Option]) }
+      def options(options)
+        options.filter_map { |option| normalize_option(option) }
+      end
+
+      sig { params(options: T::Array[EntryInput]).returns(T::Array[Entry]) }
+      def entries(options)
+        options.filter_map { |option| normalize_entry(option) }
+      end
+
+      sig { params(options: T::Array[TreeNodeInput]).returns(T::Array[HakumiComponents::SelectionControl::TreeNode]) }
+      def tree_nodes(options)
+        options.filter_map { |option| normalize_tree_node(option) }
+      end
+
+      private
+
+      sig { params(option: FlatOptionInput).returns(T.nilable(Option)) }
+      def normalize_option(option)
+        case option
+        when nil
+          nil
+        when Option
+          option
+        when Hash
+          label = option[:label] || option["label"]
+          value = scalar(option[:value] || option["value"], fallback: label)
+          return nil if label.nil?
+
+          Option.new(label: label.to_s, value: value)
+        when Array
+          label, value = option
+          return nil if label.nil?
+
+          Option.new(label: label.to_s, value: scalar(value, fallback: label))
+        else
+          Option.new(label: option.to_s, value: scalar(option, fallback: option))
+        end
+      end
+
+      sig { params(option: EntryInput).returns(T.nilable(Entry)) }
+      def normalize_entry(option)
+        case option
+        when Entry
+          option
+        when Hash
+          group_options = option[:options] || option["options"]
+          return normalize_option(option) if group_options.nil?
+
+          label = option[:label] || option["label"]
+          normalized_group_options = self.options(Kernel.Array(group_options))
+          return nil if label.nil? || normalized_group_options.empty?
+
+          OptionGroup.new(label: label.to_s, options: normalized_group_options)
+        else
+          normalize_option(option)
+        end
+      end
+
+      sig { params(option: TreeNodeInput).returns(T.nilable(HakumiComponents::SelectionControl::TreeNode)) }
+      def normalize_tree_node(option)
+        return option if option.is_a?(HakumiComponents::SelectionControl::TreeNode)
+        return nil unless option.is_a?(Hash)
+
+        label = option[:label] || option["label"]
+        value = normalize_tree_node_scalar(option[:value] || option["value"], fallback: label)
+        return nil if label.nil?
+        return nil if value.nil?
+
+        children = option[:children] || option["children"]
+        normalized_children = if children.is_a?(Array)
+          children.filter_map do |entry|
+            entry if entry.is_a?(Hash) || entry.is_a?(HakumiComponents::SelectionControl::TreeNode)
+          end
+        else
+          []
+        end
+
+        HakumiComponents::SelectionControl::TreeNode.new(
+          label: label.to_s,
+          value: value,
+          children: tree_nodes(normalized_children),
+          disabled: option[:disabled] == true || option["disabled"] == true,
+          selectable: option[:selectable] != false && option["selectable"] != false,
+          checkable: option[:checkable] != false && option["checkable"] != false,
+          disable_checkbox: option[:disable_checkbox] == true || option["disable_checkbox"] == true,
+          icon: normalize_icon(option[:icon] || option["icon"]),
+          switcher_icon: normalize_icon(option[:switcher_icon] || option["switcher_icon"]),
+          async: option[:async] == true || option["async"] == true,
+          loading: option[:loading] == true || option["loading"] == true
+        )
+      end
+
+      sig { params(value: HakumiComponents::SelectionControl::TreeNode::RawValue).returns(T.nilable(String)) }
+      def normalize_icon(value)
+        return value.to_s if value.is_a?(String) || value.is_a?(Symbol)
+
+        nil
+      end
+
+      sig do
+        params(
+          value: HakumiComponents::SelectionControl::TreeNode::RawValue,
+          fallback: HakumiComponents::SelectionControl::TreeNode::RawValue
+        ).returns(T.nilable(HakumiComponents::Types::FormFieldScalar))
+      end
+      def normalize_tree_node_scalar(value, fallback:)
+        candidate = value.nil? ? fallback : value
+        return candidate if candidate.is_a?(String) || candidate.is_a?(Symbol) || candidate.is_a?(Numeric) || candidate == true || candidate == false
+
+        nil
+      end
+    end
+  end
+end

data/app/components/hakumi_components/selection_control/entry.rb

@@ -0,0 +1,22 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module SelectionControl
+    module Entry
+      extend T::Helpers
+      extend T::Sig
+
+      interface!
+
+      sig { abstract.returns(T::Boolean) }
+      def option?; end
+
+      sig { abstract.returns(T::Boolean) }
+      def group?; end
+
+      sig { abstract.returns(String) }
+      def label; end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module SelectionControl
+    class Option
+      extend T::Sig
+
+      include Entry
+
+      sig { params(label: String, value: HakumiComponents::Types::FormFieldScalar).void }
+      def initialize(label:, value:)
+        @label = label
+        @value = value
+      end
+
+      sig { override.returns(T::Boolean) }
+      def option?
+        true
+      end
+
+      sig { override.returns(T::Boolean) }
+      def group?
+        false
+      end
+
+      sig { override.returns(String) }
+      attr_reader :label
+
+      sig { returns(HakumiComponents::Types::FormFieldScalar) }
+      attr_reader :value
+
+      sig { returns(T::Hash[Symbol, HakumiComponents::Types::FormFieldScalar]) }
+      def to_h
+        {
+          label: @label,
+          value: @value
+        }
+      end
+    end
+  end
+end

data/app/components/hakumi_components/selection_control/option_group.rb

@@ -0,0 +1,34 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module SelectionControl
+    class OptionGroup
+      extend T::Sig
+
+      include Entry
+
+      sig { params(label: String, options: T::Array[Option]).void }
+      def initialize(label:, options:)
+        @label = label
+        @options = options
+      end
+
+      sig { override.returns(T::Boolean) }
+      def option?
+        false
+      end
+
+      sig { override.returns(T::Boolean) }
+      def group?
+        true
+      end
+
+      sig { override.returns(String) }
+      attr_reader :label
+
+      sig { returns(T::Array[Option]) }
+      attr_reader :options
+    end
+  end
+end

data/app/components/hakumi_components/selection_control/tree_node.rb

@@ -0,0 +1,123 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module SelectionControl
+    class TreeNode
+      extend T::Sig
+
+      RawValue = T.type_alias do
+        T.nilable(T.any(String, Symbol, Numeric, T::Boolean, T::Array[T.untyped], T::Hash[Types::HtmlKey, T.untyped]))
+      end
+      InputHash = T.type_alias { T::Hash[Types::HtmlKey, RawValue] }
+      Input = T.type_alias { T.any(TreeNode, InputHash) }
+      Payload = T.type_alias { T::Hash[Symbol, T.nilable(T.any(String, Symbol, Numeric, T::Boolean, T::Array[T.untyped]))] }
+
+      sig do
+        params(
+          label: String,
+          value: HakumiComponents::Types::FormFieldScalar,
+          children: T::Array[TreeNode],
+          disabled: T::Boolean,
+          selectable: T::Boolean,
+          checkable: T::Boolean,
+          disable_checkbox: T::Boolean,
+          icon: T.nilable(String),
+          switcher_icon: T.nilable(String),
+          async: T::Boolean,
+          loading: T::Boolean
+        ).void
+      end
+      def initialize(
+        label:,
+        value:,
+        children: [],
+        disabled: false,
+        selectable: true,
+        checkable: true,
+        disable_checkbox: false,
+        icon: nil,
+        switcher_icon: nil,
+        async: false,
+        loading: false
+      )
+        @label = label
+        @value = value
+        @children = children
+        @disabled = disabled
+        @selectable = selectable
+        @checkable = checkable
+        @disable_checkbox = disable_checkbox
+        @icon = icon
+        @switcher_icon = switcher_icon
+        @async = async
+        @loading = loading
+      end
+
+      sig { returns(String) }
+      attr_reader :label
+
+      sig { returns(HakumiComponents::Types::FormFieldScalar) }
+      attr_reader :value
+
+      sig { returns(T::Array[TreeNode]) }
+      attr_reader :children
+
+      sig { returns(T::Boolean) }
+      attr_reader :disabled
+
+      sig { returns(T::Boolean) }
+      attr_reader :selectable
+
+      sig { returns(T::Boolean) }
+      attr_reader :checkable
+
+      sig { returns(T::Boolean) }
+      attr_reader :disable_checkbox
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :icon
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :switcher_icon
+
+      sig { returns(T::Boolean) }
+      attr_reader :async
+
+      sig { returns(T::Boolean) }
+      attr_reader :loading
+
+      sig { returns(String) }
+      def string_value
+        @value.to_s
+      end
+
+      sig { returns(Payload) }
+      def to_tree_node
+        {
+          key: string_value,
+          title: @label,
+          children: @children.map(&:to_tree_node),
+          disabled: @disabled,
+          selectable: @selectable,
+          checkable: @checkable,
+          disable_checkbox: @disable_checkbox,
+          icon: @icon,
+          switcher_icon: @switcher_icon,
+          async: @async,
+          loading: @loading
+        }.compact
+      end
+
+      sig { returns(Payload) }
+      def to_cascader_option
+        {
+          value: @value,
+          label: @label,
+          disabled: @disabled,
+          children: @children.map(&:to_cascader_option)
+        }.compact
+      end
+    end
+  end
+end

data/app/components/hakumi_components/skeleton/avatar/component.rb

@@ -1,33 +1,50 @@
+# typed: strict
 # frozen_string_literal: true
 
 module HakumiComponents
   module Skeleton
     module Avatar
       class Component < HakumiComponents::BaseComponent
-        SIZES = [ :small, :default, :large ].freeze
-        SHAPES = [ :circle, :square ].freeze
-
+        extend T::Sig
+
+        AvatarSize = T.type_alias { T.any(Symbol, Numeric) }
+        ShapeInput = T.type_alias { Types::HtmlKey }
+        SHAPES = T.let(%i[circle square].freeze, T::Array[Symbol])
+
+        sig do
+          params(
+            active: T::Boolean,
+            size: AvatarSize,
+            shape: ShapeInput,
+            html_options: Types::HtmlAttributeValue
+          ).void
+        end
         def initialize(active: false, size: :default, shape: :circle, **html_options)
-          @active = active
-          @size = normalize_size(size)
-          @shape = normalize_shape(shape)
-          @html_options = html_options
+          @active = T.let(active, T::Boolean)
+          @size = T.let(normalize_size(size), AvatarSize)
+          @shape = T.let(normalize_shape(shape), Symbol)
+          @html_options = T.let(html_options, Types::HtmlAttributes)
 
           validate_props!
         end
 
+        sig { returns(Types::HtmlAttributes) }
         def wrapper_attributes
           merge_attributes({ class: wrapper_classes }, @html_options.except(:class))
         end
 
+        sig { returns(String) }
         def avatar_classes
-          modifiers = {}
-          modifiers[@size] = true if @size && !@size.is_a?(Numeric) && @size != :default
-          modifiers[@shape] = true if @shape
+          modifiers = T.let({}, Types::ClassModifiers)
+          if !@size.is_a?(Numeric) && @size != :default
+            modifiers[@size] = true
+          end
+          modifiers[@shape] = true
 
           class_names("skeleton-avatar", modifiers)
         end
 
+        sig { returns(T.nilable(String)) }
         def avatar_style
           return nil unless @size.is_a?(Numeric)
 
@@ -36,26 +53,31 @@ module HakumiComponents
 
         private
 
+        sig { params(size: AvatarSize).returns(AvatarSize) }
         def normalize_size(size)
           return size if size.is_a?(Numeric)
 
           size.to_sym
         end
 
+        sig { params(shape: ShapeInput).returns(Symbol) }
         def normalize_shape(shape)
           shape.to_sym
         end
 
+        sig { returns(String) }
         def wrapper_classes
-          class_names("skeleton", { element: true, active: @active }, @html_options[:class])
+          component_classes("skeleton", { element: true, active: @active }, @html_options)
         end
 
+        sig { void }
         def validate_props!
-          validate_inclusion_value(:size, @size, SIZES) if @size && !@size.is_a?(Numeric)
-          validate_inclusion_value(:shape, @shape, SHAPES) if @shape
+          validate_inclusion_value(name: :size, value: @size, allowed: SIZES) if !@size.is_a?(Numeric)
+          validate_inclusion_value(name: :shape, value: @shape, allowed: SHAPES)
         end
 
-        def validate_inclusion_value(name, value, allowed)
+        sig { params(name: Symbol, value: Symbol, allowed: T::Array[Symbol]).void }
+        def validate_inclusion_value(name:, value:, allowed:)
           return if allowed.include?(value)
 
           raise ArgumentError, "#{name} must be one of #{allowed.inspect}, got #{value.inspect}"