hakumi_components 0.1.18.pre → 0.1.19.pre

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

@@ -1,27 +1,18 @@
+# typed: strict
 # frozen_string_literal: true
 
 module HakumiComponents
   module Dropdown
     class Component < HakumiComponents::BaseComponent
-      TRIGGERS = %i[hover click context_menu].freeze
-      PLACEMENTS = %i[bottom bottom_left bottom_right top top_left top_right].freeze
+      extend T::Sig
+
+      TRIGGERS = T.let(%i[hover click context_menu].freeze, T::Array[Symbol])
+      PLACEMENTS = T.let(%i[bottom bottom_left bottom_right top top_left top_right].freeze, T::Array[Symbol])
 
       renders_one :trigger
       renders_many :items, types: {
         item: {
-          renders: ->(key:, label: nil, href: nil, target: nil, icon: nil, disabled: false, danger: false, **options, &block) do
-            HakumiComponents::Dropdown::Item::Component.new(
-              key: key,
-              label: label,
-              href: href,
-              target: target,
-              icon: icon,
-              disabled: disabled,
-              danger: danger,
-              **options,
-              &block
-            )
-          end,
+          renders: HakumiComponents::Dropdown::Item::Component,
           as: :item
         },
         divider: {
@@ -30,55 +21,62 @@ module HakumiComponents
         }
       }
 
+      sig do
+        params(
+          trigger: Symbol,
+          placement: Symbol,
+          disabled: T::Boolean,
+          arrow: T::Boolean,
+          html_options: Types::HtmlAttributeValue
+        ).void
+      end
       def initialize(
         trigger: :hover,
         placement: :bottom_left,
         disabled: false,
+        arrow: false,
         **html_options
       )
-        @trigger = trigger
-        @placement = placement
-        @disabled = disabled
-        @html_options = html_options
+        @trigger = T.let(trigger, Symbol)
+        @placement = T.let(placement, Symbol)
+        @disabled = T.let(disabled, T::Boolean)
+        @arrow = T.let(arrow, T::Boolean)
+        @html_options = T.let(html_options, Types::HtmlAttributes)
 
         validate_props!
       end
 
-      attr_reader :trigger_type, :placement, :disabled
+      private
 
+      sig { returns(String) }
       def dropdown_classes
-        classes = [ "hakumi-dropdown-trigger" ]
-        classes << "hakumi-dropdown-disabled" if @disabled
-        classes.join(" ")
+        extra = @disabled ? "hakumi-dropdown-disabled" : nil
+        class_names("dropdown-trigger", {}, extra)
       end
 
+      sig { returns(String) }
       def menu_classes
         "hakumi-dropdown-menu"
       end
 
+      sig { returns(String) }
       def stimulus_controller
         "hakumi--dropdown"
       end
 
-      def stimulus_values
-        {
-          trigger: @trigger.to_s,
-          placement: @placement.to_s.dasherize,
-          disabled: @disabled
-        }
-      end
-
+      sig { returns(String) }
       def placement_class
         "hakumi-dropdown-placement-#{@placement.to_s.dasherize}"
       end
 
+      sig { returns(Types::HtmlAttributes) }
       def wrapper_attributes
-        base_data = {
+        base_data = T.let({
           controller: stimulus_controller,
           "#{stimulus_controller}-trigger-value" => @trigger.to_s,
           "#{stimulus_controller}-placement-value" => @placement.to_s.dasherize,
           "#{stimulus_controller}-disabled-value" => @disabled.to_s
-        }
+        }, Types::DataAttributes)
 
         merge_attributes(
           { class: dropdown_classes, data: base_data },
@@ -86,8 +84,7 @@ module HakumiComponents
         )
       end
 
-      private
-
+      sig { void }
       def validate_props!
         validate_inclusion!(:trigger, TRIGGERS)
         validate_inclusion!(:placement, PLACEMENTS)

data/app/components/hakumi_components/dropdown/divider/component.rb

@@ -1,9 +1,13 @@
+# typed: strict
 # frozen_string_literal: true
 
 module HakumiComponents
   module Dropdown
     module Divider
       class Component < HakumiComponents::BaseComponent
+        extend T::Sig
+
+        sig { returns(ActiveSupport::SafeBuffer) }
         def call
           tag.li(class: "hakumi-dropdown-menu-item-divider", role: "separator")
         end

data/app/components/hakumi_components/dropdown/item/component.rb

@@ -1,45 +1,71 @@
+# typed: strict
 # frozen_string_literal: true
 
 module HakumiComponents
   module Dropdown
     module Item
       class Component < HakumiComponents::BaseComponent
+        extend T::Sig
+
+        sig do
+          params(
+            key: String,
+            label: T.nilable(String),
+            href: T.nilable(String),
+            target: T.nilable(String),
+            icon: T.nilable(T.any(Symbol, ViewComponent::Base)),
+            disabled: T::Boolean,
+            danger: T::Boolean,
+            html_options: Types::HtmlAttributeValue
+          ).void
+        end
         def initialize(key:, label: nil, href: nil, target: nil, icon: nil, disabled: false, danger: false, **html_options)
-          @key = key
-          @label = label
-          @href = href
-          @target = target
-          @icon = icon
-          @disabled = disabled
-          @danger = danger
-          @html_options = html_options
+          @key = T.let(key, String)
+          @label = T.let(label, T.nilable(String))
+          @href = T.let(href, T.nilable(String))
+          @target = T.let(target, T.nilable(String))
+          @icon = T.let(icon, T.nilable(T.any(Symbol, ViewComponent::Base)))
+          @disabled = T.let(disabled, T::Boolean)
+          @danger = T.let(danger, T::Boolean)
+          @html_options = T.let(html_options, Types::HtmlAttributes)
         end
 
-        attr_reader :key, :label, :href, :target, :icon, :disabled, :danger
+        sig { returns(String) }
+        attr_reader :key
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :label, :href, :target
+
+        sig { returns(T.nilable(T.any(Symbol, ViewComponent::Base))) }
+        attr_reader :icon
+
+        sig { returns(T::Boolean) }
+        attr_reader :disabled, :danger
 
+        sig { returns(String) }
         def item_classes
-          classes = [ "hakumi-dropdown-menu-item" ]
+          classes = T.let([ "hakumi-dropdown-menu-item" ], T::Array[String])
           classes << "hakumi-dropdown-menu-item-disabled" if disabled
           classes << "hakumi-dropdown-menu-item-danger" if danger
           classes.join(" ")
         end
 
+        sig { returns(T::Boolean) }
         def link?
           href.present?
         end
 
+        sig { returns(Types::RenderedContent) }
         def display_label
           content.presence || label
         end
 
+        sig { returns(T.nilable(ViewComponent::Base)) }
         def icon_component
-          return nil unless icon
+          ic = @icon
+          return nil if ic.nil?
 
-          if icon.is_a?(Symbol)
-            HakumiComponents::Icon::Component.new(name: icon)
-          else
-            icon
-          end
+          ic.is_a?(Symbol) ? HakumiComponents::Icon::Component.new(name: ic) : ic
         end
       end
     end

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

@@ -1,13 +1,19 @@
+# typed: strict
 # frozen_string_literal: true
 
 module HakumiComponents
   module Empty
     class Component < HakumiComponents::BaseComponent
-      BUILT_IN_IMAGES = [ :default, :simple ].freeze
+      extend T::Sig
+
+      Image = T.type_alias { T.any(Symbol, String, ActiveSupport::SafeBuffer, ViewComponent::Base, ViewComponent::Slot) }
+      Description = T.type_alias { T.any(FalseClass, HakumiComponents::Types::Renderable) }
+
+      BUILT_IN_IMAGES = T.let([ :default, :simple ].freeze, T::Array[Symbol])
 
       # Default SVG image matching Ant Design's PRESENTED_IMAGE_DEFAULT
       # Uses CSS classes for dark mode theming
-      DEFAULT_IMAGE_SVG = <<~SVG.html_safe
+      DEFAULT_IMAGE_SVG = T.let(<<~SVG.html_safe, ActiveSupport::SafeBuffer)
         <svg class="hakumi-empty-img-default" width="184" height="152" viewBox="0 0 184 152" xmlns="http://www.w3.org/2000/svg">
           <g fill="none" fill-rule="evenodd">
             <g transform="translate(24 31.67)">
@@ -27,7 +33,7 @@ module HakumiComponents
       SVG
 
       # Simple SVG image matching Ant Design's PRESENTED_IMAGE_SIMPLE
-      SIMPLE_IMAGE_SVG = <<~SVG.html_safe
+      SIMPLE_IMAGE_SVG = T.let(<<~SVG.html_safe, ActiveSupport::SafeBuffer)
         <svg class="hakumi-empty-img-simple" width="64" height="41" viewBox="0 0 64 41" xmlns="http://www.w3.org/2000/svg">
           <g transform="translate(0 1)" fill="none" fill-rule="evenodd">
             <ellipse class="hakumi-empty-img-simple-ellipse" cx="32" cy="33" rx="32" ry="7"/>
@@ -39,21 +45,32 @@ module HakumiComponents
         </svg>
       SVG
 
-      DEFAULT_DESCRIPTION = "No data"
+      sig do
+        params(
+          image: Image,
+          image_height: T.nilable(T.any(Integer, String)),
+          description: T.nilable(Description),
+          html_options: Types::HtmlAttributeValue
+        ).void
+      end
+      def initialize(image: :default, image_height: nil, description: nil, **html_options)
+        @image = T.let(image, Image)
+        @image_height = T.let(image_height, T.nilable(T.any(Integer, String)))
+        @description = T.let(description, T.nilable(Description))
+        @html_options = T.let(html_options, Types::HtmlAttributes)
 
-      def initialize(image: :default, image_height: nil, description: DEFAULT_DESCRIPTION, **html_options)
-        @image = image
-        @image_height = image_height
-        @description = description
-        @html_options = html_options
+        validate_props!
       end
 
-      def call
-        classes = [ "hakumi-empty" ]
-        classes << "hakumi-empty-normal" if @image == :simple
-        classes << @html_options[:class] if @html_options[:class].present?
+      sig { returns(HakumiComponents::Types::Renderable) }
+      def resolved_description
+        return nil if @description == false
+        @description || t_default(:description, default: "No data")
+      end
 
-        content_tag(:div, class: classes.join(" "), **@html_options.except(:class)) do
+      sig { returns(ActiveSupport::SafeBuffer) }
+      def call
+        content_tag(:div, wrapper_attributes) do
           safe_join([
             image_element,
             description_element,
@@ -62,48 +79,66 @@ module HakumiComponents
         end
       end
 
+      sig { returns(String) }
+      def wrapper_classes
+        component_classes("empty", { normal: @image == :simple }, @html_options)
+      end
+
+      sig { returns(Types::HtmlAttributes) }
+      def wrapper_attributes
+        merge_attributes({ class: wrapper_classes }, @html_options.except(:class))
+      end
+
       private
 
+      sig { void }
+      def validate_props!
+        return unless @image.is_a?(Symbol)
+        return if BUILT_IN_IMAGES.include?(@image)
+
+        raise ArgumentError, "image must be one of #{BUILT_IN_IMAGES.inspect}, got #{@image.inspect}"
+      end
+
+      sig { returns(ActiveSupport::SafeBuffer) }
       def image_element
-        image_style = @image_height ? "height: #{@image_height}px" : nil
+        image_style = dimension_to_css(@image_height)
 
-        tag.div(class: "hakumi-empty-image", style: image_style) do
-          render_image
-        end
+        content_tag(:div, render_image, class: "hakumi-empty-image", style: image_style ? "height: #{image_style};" : nil)
       end
 
+      sig { returns(HakumiComponents::Types::RenderedContent) }
       def render_image
-        case @image
-        when :default
+        if @image == :default
           DEFAULT_IMAGE_SVG
-        when :simple
+        elsif @image == :simple
           SIMPLE_IMAGE_SVG
-        when String
+        elsif @image.is_a?(ViewComponent::Base) || @image.is_a?(ViewComponent::Slot) || @image.is_a?(ActiveSupport::SafeBuffer)
+          render_value(@image)
+        elsif @image.is_a?(String)
           tag.img(src: @image, alt: image_alt, draggable: false)
         else
-          # Assume it's renderable content (ViewComponent or other)
-          @image
+          nil
         end
       end
 
+      sig { returns(String) }
       def image_alt
-        @description.is_a?(String) ? @description : "empty"
+        desc = resolved_description
+        desc.is_a?(String) ? desc : "empty"
       end
 
+      sig { returns(T.nilable(ActiveSupport::SafeBuffer)) }
       def description_element
         return nil if @description == false
 
-        tag.div(class: "hakumi-empty-description") do
-          @description
-        end
+        content_tag(:div, render_value(resolved_description), class: "hakumi-empty-description")
       end
 
+      sig { returns(T.nilable(ActiveSupport::SafeBuffer)) }
       def footer_element
         return nil unless content.present?
 
-        tag.div(class: "hakumi-empty-footer") do
-          content
-        end
+        content_tag(:div, render_value(content), class: "hakumi-empty-footer")
       end
     end
   end

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

@@ -1,13 +1,29 @@
+# typed: strict
 # frozen_string_literal: true
 
 module HakumiComponents
   module Flex
     class Component < HakumiComponents::BaseComponent
-      WRAP_OPTIONS = [ :wrap, :nowrap, :"wrap-reverse" ].freeze
-      JUSTIFY_OPTIONS = [ :start, :end, :center, :"space-between", :"space-around", :"space-evenly" ].freeze
-      ALIGN_OPTIONS = [ :start, :end, :center, :baseline, :stretch ].freeze
-      GAP_OPTIONS = [ :small, :middle, :large ].freeze
+      extend T::Sig
 
+      PropValue = T.type_alias { T.nilable(T.any(Symbol, Numeric, String)) }
+
+      WRAPS = T.let([ :wrap, :nowrap, :"wrap-reverse" ].freeze, T::Array[Symbol])
+      JUSTIFY_VALUES = T.let([ :start, :end, :center, :"space-between", :"space-around", :"space-evenly" ].freeze, T::Array[Symbol])
+      ALIGN_VALUES = T.let([ :start, :end, :center, :baseline, :stretch ].freeze, T::Array[Symbol])
+      GAPS = T.let([ :small, :default, :large ].freeze, T::Array[Symbol])
+
+      sig do
+        params(
+          vertical: T::Boolean,
+          wrap: PropValue,
+          justify: PropValue,
+          align: PropValue,
+          gap: PropValue,
+          component: Symbol,
+          html_options: HakumiComponents::Types::HtmlAttributeValue
+        ).void
+      end
       def initialize(
         vertical: false,
         wrap: :nowrap,
@@ -17,31 +33,33 @@ module HakumiComponents
         component: :div,
         **html_options
       )
-        @vertical = vertical
-
-        @wrap = normalize_prop(wrap)
-        @justify = normalize_prop(justify)
-        @align = align
-        @gap = gap
-        @component = component
-        @html_options = html_options
+        @vertical = T.let(vertical, T::Boolean)
+        @wrap = T.let(normalize_prop(wrap), PropValue)
+        @justify = T.let(normalize_prop(justify), PropValue)
+        @align = T.let(align, PropValue)
+        @gap = T.let(gap, PropValue)
+        @component = T.let(component, Symbol)
+        @html_options = T.let(html_options, HakumiComponents::Types::HtmlAttributes)
 
         validate_props!
       end
 
+      sig { returns(ActiveSupport::SafeBuffer) }
       def call
         content_tag(@component, content, wrapper_attributes)
       end
 
       private
 
+      sig { void }
       def validate_props!
-        validate_inclusion!(:wrap, WRAP_OPTIONS) if @wrap.is_a?(Symbol)
-        validate_inclusion!(:justify, JUSTIFY_OPTIONS)
-        validate_inclusion!(:align, ALIGN_OPTIONS)
-        validate_inclusion!(:gap, GAP_OPTIONS) if @gap.is_a?(Symbol)
+        validate_inclusion!(:wrap, WRAPS) if @wrap.is_a?(Symbol)
+        validate_inclusion!(:justify, JUSTIFY_VALUES)
+        validate_inclusion!(:align, ALIGN_VALUES)
+        validate_inclusion!(:gap, GAPS) if @gap.is_a?(Symbol)
       end
 
+      sig { returns(String) }
       def wrapper_classes
         class_names(
           "flex",
@@ -52,16 +70,14 @@ module HakumiComponents
             "align-#{@align}": @align != :start,
             "gap-#{@gap}": @gap.is_a?(Symbol)
           },
-          [ @html_options[:class] ]
+          html_classes(@html_options)
         )
       end
 
+      sig { returns(HakumiComponents::Types::HtmlAttributes) }
       def wrapper_attributes
-        attrs = {
-          class: wrapper_classes
-        }
+        attrs = T.let({ class: wrapper_classes }, HakumiComponents::Types::HtmlAttributes)
 
-        # Handle numeric gap or custom gap string
         if @gap.present? && !@gap.is_a?(Symbol)
           attrs[:style] = "gap: #{@gap.is_a?(Numeric) ? "#{@gap}px" : @gap};"
         end
@@ -69,8 +85,10 @@ module HakumiComponents
         merge_attributes(attrs, @html_options.except(:class))
       end
 
+      sig { params(prop: PropValue).returns(PropValue) }
       def normalize_prop(prop)
         return prop unless prop.is_a?(Symbol)
+
         prop.to_s.tr("_", "-").to_sym
       end
     end

data/app/components/hakumi_components/float_button/back_top/component.rb

@@ -1,11 +1,27 @@
+# typed: strict
 # frozen_string_literal: true
 
 module HakumiComponents
   module FloatButton
     module BackTop
       class Component < HakumiComponents::BaseComponent
+        extend T::Sig
+
         DEFAULT_VISIBILITY = 400
 
+        sig do
+          params(
+            icon: HakumiComponents::FloatButton::Component::IconValue,
+            tooltip: String,
+            visibility_height: Integer,
+            target_selector: T.nilable(String),
+            floating: T::Boolean,
+            placement: Symbol,
+            offset: T.nilable(HakumiComponents::FloatButton::PositionConfig::OffsetMap),
+            button_options: Types::HtmlAttributes,
+            html_options: Types::HtmlAttributeValue
+          ).void
+        end
         def initialize(
           icon: :vertical_align_top,
           tooltip: "Back to top",
@@ -17,17 +33,18 @@ module HakumiComponents
           button_options: {},
           **html_options
         )
-          @icon = icon
-          @tooltip = tooltip
-          @visibility_height = visibility_height
-          @target_selector = target_selector
-          @floating = floating
-          @placement = placement
-          @offset = offset
-          @button_options = button_options
-          @html_options = html_options
+          @icon = T.let(icon, HakumiComponents::FloatButton::Component::IconValue)
+          @tooltip = T.let(tooltip, String)
+          @visibility_height = T.let(visibility_height, Integer)
+          @target_selector = T.let(target_selector, T.nilable(String))
+          @floating = T.let(floating, T::Boolean)
+          @placement = T.let(placement, Symbol)
+          @offset = T.let(offset, T.nilable(HakumiComponents::FloatButton::PositionConfig::OffsetMap))
+          @button_options = T.let(button_options, Types::HtmlAttributes)
+          @html_options = T.let(html_options, Types::HtmlAttributes)
         end
 
+        sig { returns(Types::RenderedContent) }
         def call
           render HakumiComponents::FloatButton::Component.new(
             icon: @icon,
@@ -42,37 +59,27 @@ module HakumiComponents
 
         private
 
+        sig { returns(Types::HtmlAttributes) }
         def back_top_html_options
           options = @html_options.deep_dup
-          options[:class] = class_names("float-button-back-top", {}, [ @html_options[:class] ])
+          options[:class] = class_names("float-button-back-top", {}, html_classes(@html_options))
 
-          data = (options[:data] || {}).dup
-          data[:controller] = append_controller(data[:controller], "hakumi--float-button-back-top")
-          data["hakumi--float-button-back-top-visibility-height-value"] = @visibility_height
-          data["hakumi--float-button-back-top-target-selector-value"] = @target_selector if @target_selector.present?
+          data = data_attributes_from(options[:data])
+          data[:controller] = append_data_token(data[:controller], "hakumi--back-top")
+          data["hakumi--back-top-visibility-height-value"] = @visibility_height
+          data["hakumi--back-top-target-selector-value"] = @target_selector if @target_selector.present?
           options[:data] = data
           options
         end
 
+        sig { returns(Types::HtmlAttributes) }
         def back_top_button_options
           options = @button_options.deep_dup
-          data = (options[:data] || {}).dup
-          data[:action] = append_action(data[:action], "click->hakumi--float-button-back-top#scroll")
+          data = data_attributes_from(options[:data])
+          data[:action] = append_data_token(data[:action], "click->hakumi--back-top#scroll")
           options[:data] = data
           options
         end
-
-        def append_controller(existing, controller)
-          return controller if existing.blank?
-
-          [ existing, controller ].join(" ")
-        end
-
-        def append_action(existing, action)
-          return action if existing.blank?
-
-          [ existing, action ].join(" ")
-        end
       end
     end
   end