hakumi_components 0.1.18.pre → 0.1.19.pre

data/app/components/hakumi_components/space/compact/component.rb

@@ -1,34 +1,50 @@
+# typed: strict
+# frozen_string_literal: true
+
 module HakumiComponents
   module Space
     module Compact
-      class Component < ViewComponent::Base
+      class Component < HakumiComponents::BaseComponent
+        extend T::Sig
+        DIRECTIONS = T.let(%i[horizontal vertical].freeze, T::Array[Symbol])
+
+        sig do
+          params(
+            direction: T.any(Symbol, String),
+            block: T::Boolean,
+            html_options: HakumiComponents::Types::HtmlAttributeValue
+          ).void
+        end
         def initialize(direction: :horizontal, block: false, **html_options)
-          @direction = direction
-          @block = block
-          @html_options = html_options
+          @direction = T.let(direction.to_sym, Symbol)
+          @block = T.let(block, T::Boolean)
+          @html_options = T.let(html_options, HakumiComponents::Types::HtmlAttributes)
+
+          validate_props!
         end
 
         private
 
-        def html_attributes
-          attrs = @html_options.dup
-          attrs[:class] = css_classes
-          attrs[:style] = inline_styles
-          attrs
+        sig { void }
+        def validate_props!
+          validate_inclusion!(:direction, DIRECTIONS)
         end
 
-        def css_classes
-          classes = [ "hakumi-space-compact" ]
-          classes << "hakumi-space-compact-#{@direction}"
-          classes << "hakumi-space-compact-block" if @block
-          classes << @html_options[:class] if @html_options[:class]
-          classes.join(" ")
+        sig { returns(String) }
+        def wrapper_classes
+          class_names(
+            "space-compact",
+            { @direction => true, block: @block },
+            html_classes(@html_options)
+          )
         end
 
-        def inline_styles
-          styles = []
-          styles << @html_options[:style] if @html_options[:style]
-          styles.join("; ")
+        sig { returns(HakumiComponents::Types::HtmlAttributes) }
+        def wrapper_attributes
+          merge_attributes(
+            { class: wrapper_classes },
+            @html_options.except(:class)
+          )
         end
       end
     end

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

@@ -1,4 +1,4 @@
-<div <%= tag.attributes(html_attributes) %>>
+<div <%= tag.attributes(wrapper_attributes) %>>
   <% if items? %>
     <% items.each_with_index do |item, index| %>
       <%= item %>

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

@@ -1,69 +1,105 @@
+# typed: strict
+# frozen_string_literal: true
+
 module HakumiComponents
   module Space
-    class Component < ViewComponent::Base
+    class Component < HakumiComponents::BaseComponent
+      extend T::Sig
+
+      Direction = T.type_alias { T.any(Symbol, String) }
+      Size = T.type_alias { T.any(Symbol, Integer) }
+
+      DIRECTIONS = T.let(%i[horizontal vertical].freeze, T::Array[Symbol])
+      ALIGNMENTS = T.let(%i[start center end baseline].freeze, T::Array[Symbol])
+
       renders_many :items, "ItemComponent"
 
+      sig do
+        params(
+          direction: Direction,
+          size: Size,
+          align: T.nilable(T.any(Symbol, String)),
+          wrap: T::Boolean,
+          block: T::Boolean,
+          split: HakumiComponents::Types::Renderable,
+          html_options: HakumiComponents::Types::HtmlAttributeValue
+        ).void
+      end
       def initialize(direction: :horizontal, size: :small, align: nil, wrap: false, block: false, split: nil, **html_options)
-        @direction = direction
-        @size = size
-        @align = align
-        @wrap = wrap
-        @block = block
-        @split = split
-        @html_options = html_options
+        @direction = T.let(direction.to_sym, Symbol)
+        @size = T.let(size, Size)
+        @align = T.let(align&.to_sym, T.nilable(Symbol))
+        @wrap = T.let(wrap, T::Boolean)
+        @block = T.let(block, T::Boolean)
+        @split = T.let(split, HakumiComponents::Types::Renderable)
+        @html_options = T.let(html_options, HakumiComponents::Types::HtmlAttributes)
+
+        validate_props!
       end
 
+      sig { returns(HakumiComponents::Types::Renderable) }
       attr_reader :split
 
       private
 
-      def html_attributes
-        attrs = @html_options.dup
-        attrs[:class] = css_classes
-        attrs[:style] = inline_styles
-        attrs
+      sig { void }
+      def validate_props!
+        validate_inclusion!(:direction, DIRECTIONS)
+        validate_inclusion!(:align, ALIGNMENTS) if @align
+        validate_size!
       end
 
-      def css_classes
-        classes = [ "hakumi-space" ]
-        classes << "hakumi-space-#{@direction}"
-        classes << "hakumi-space-align-#{@align}" if @align
-        classes << "hakumi-space-wrap" if @wrap
-        classes << "hakumi-space-block" if @block
-        classes << @html_options[:class] if @html_options[:class]
-        classes.join(" ")
+      sig { void }
+      def validate_size!
+        return if @size.is_a?(Integer)
+        return if SIZES.include?(@size)
+
+        raise ArgumentError, "size must be one of #{SIZES.inspect} or an Integer, got #{@size.inspect}"
       end
 
-      def inline_styles
-        styles = []
+      sig { returns(String) }
+      def wrapper_classes
+        class_names(
+          "space",
+          {
+            @direction => true,
+            "align-#{@align}": @align.present?,
+            wrap: @wrap,
+            block: @block
+          },
+          html_classes(@html_options)
+        )
+      end
 
+      sig { returns(HakumiComponents::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
         gap_size = case @size
         when :small then "8px"
-        when :middle then "16px"
+        when :default then "16px"
         when :large then "24px"
         when Integer then "#{@size}px"
         else "8px"
         end
 
-        styles << "gap: #{gap_size}"
-        styles << @html_options[:style] if @html_options[:style]
-        styles.join("; ")
-      end
+        styles = T.let([ "gap: #{gap_size}" ], T::Array[String])
+        custom_style = html_style(@html_options)
+        styles << custom_style if custom_style
 
-      def call
-        return nil if items.empty?
-
-        safe_join(items.map { |item| content_tag(:div, item, class: "hakumi-space-item") }, split_content)
+        build_inline_style(styles) || "gap: #{gap_size}"
       end
 
-      private
-
-      def split_content
-        return nil unless @split
-
-        content_tag(:div, @split, class: "hakumi-space-split")
-      end
       class ItemComponent < ViewComponent::Base
+        extend T::Sig
+
+        sig { returns(ActiveSupport::SafeBuffer) }
         def call
           content_tag(:div, content, class: "hakumi-space-item")
         end

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

@@ -1,39 +1,67 @@
+# typed: strict
 # frozen_string_literal: true
 
 module HakumiComponents
   module Spin
     class Component < HakumiComponents::BaseComponent
-      SIZES = [ :small, :default, :large ].freeze
+      extend T::Sig
 
+      DelayInput = T.type_alias { BaseComponent::DimensionInput }
+      ProgressPercent = T.type_alias { T.nilable(T.any(Numeric, Symbol)) }
+      PercentInput = T.type_alias { T.nilable(T.any(Numeric, Symbol, String)) }
+      TipContent = T.type_alias { T.nilable(Types::Renderable) }
+      ControllerLocalValue = T.type_alias { Types::HtmlPrimitive }
+
+      sig do
+        params(params: BaseComponent::ControllerOptions).returns(T::Hash[Symbol, ControllerLocalValue])
+      end
       def self.extract_controller_locals(params)
+        spinning_value = html_param(params, :spinning)
+
         {
-          spinning: params.key?(:spinning) ? ActiveModel::Type::Boolean.new.cast(params[:spinning]) : true,
-          size: params[:size]&.to_sym,
-          tip: params[:tip],
-          delay: parse_delay(params[:delay]),
-          fullscreen: ActiveModel::Type::Boolean.new.cast(params[:fullscreen]),
-          percent: parse_percent(params[:percent])
+          spinning: spinning_value.nil? ? true : boolean_html_param(spinning_value) != false,
+          size: symbol_html_param(html_param(params, :size)),
+          tip: string_html_param(html_param(params, :tip)),
+          delay: parse_delay(html_param(params, :delay)),
+          fullscreen: boolean_html_param(html_param(params, :fullscreen)) == true,
+          percent: parse_percent(html_param(params, :percent))
         }
       end
 
+      sig { params(value: Types::HtmlAttributeValue).returns(T.nilable(Integer)) }
       def self.parse_delay(value)
         return nil if value.nil?
-        return value if value.is_a?(Numeric)
+        return value if value.is_a?(Integer)
+        return value.to_i if value.is_a?(Float)
 
         value.to_s.strip.presence&.to_i
       end
 
+      sig { params(value: Types::HtmlAttributeValue).returns(ProgressPercent) }
       def self.parse_percent(value)
         return nil if value.nil?
 
         string_value = value.to_s.strip
         return :auto if string_value == "auto"
 
-        return value if value.is_a?(Numeric)
+        return value if value.is_a?(Integer)
+        return value if value.is_a?(Float)
 
         string_value.presence&.to_f
       end
 
+      sig do
+        params(
+          spinning: T::Boolean,
+          size: T.nilable(Symbol),
+          tip: TipContent,
+          delay: DelayInput,
+          indicator: TipContent,
+          fullscreen: T::Boolean,
+          percent: PercentInput,
+          html_options: Types::HtmlAttributeValue
+        ).void
+      end
       def initialize(
         spinning: true,
         size: :default,
@@ -44,18 +72,19 @@ module HakumiComponents
         percent: nil,
         **html_options
       )
-        @spinning = ActiveModel::Type::Boolean.new.cast(spinning)
-        @size = (size || :default).to_sym
-        @tip = tip
-        @delay = delay
-        @indicator = indicator
-        @fullscreen = fullscreen
-        @percent = normalize_percent(percent)
-        @html_options = html_options
+        @spinning = T.let(cast_boolean(spinning) == true, T::Boolean)
+        @size = T.let(size.nil? ? :default : size.to_sym, Symbol)
+        @tip = T.let(tip, TipContent)
+        @delay = T.let(normalize_delay(delay), Integer)
+        @indicator = T.let(indicator, TipContent)
+        @fullscreen = T.let(fullscreen, T::Boolean)
+        @percent = T.let(normalize_percent(percent), ProgressPercent)
+        @html_options = T.let(html_options, Types::HtmlAttributes)
 
         validate_props!
       end
 
+      sig { returns(Types::HtmlAttributes) }
       def wrapper_attributes
         merge_attributes(
           {
@@ -69,10 +98,12 @@ module HakumiComponents
         )
       end
 
+      sig { returns(T::Boolean) }
       def nested?
-        content? && !@fullscreen
+        content.present? && !@fullscreen
       end
 
+      sig { returns(Types::RenderedContent) }
       def indicator_markup
         return render_value(@indicator) if @indicator.present?
         return progress_indicator if progress?
@@ -80,25 +111,33 @@ module HakumiComponents
         default_indicator
       end
 
+      sig { returns(Types::RenderedContent) }
       def tip_markup
         render_value(@tip)
       end
 
+      sig { returns(T::Boolean) }
       def show_text?
         @tip.present?
       end
 
+      sig { returns(T::Boolean) }
       def progress?
         !@percent.nil?
       end
 
+      sig { returns(T::Boolean) }
       def progress_auto?
         @percent == :auto
       end
 
+      sig { returns(HakumiComponents::Progress::Component) }
       def progress_component
+        percent = numeric_percent
+        raise "progress_component requires numeric percent" if percent.nil?
+
         HakumiComponents::Progress::Component.new(
-          percent: @percent,
+          percent: percent,
           type: :circle,
           size: progress_size,
           stroke_width: 6,
@@ -108,6 +147,7 @@ module HakumiComponents
 
       private
 
+      sig { void }
       def validate_props!
         validate_inclusion!(:size, SIZES)
 
@@ -124,6 +164,7 @@ module HakumiComponents
         @percent = @percent.clamp(0, 100)
       end
 
+      sig { returns(String) }
       def wrapper_classes
         modifiers = {
           spinning: spinning_class?,
@@ -137,17 +178,16 @@ module HakumiComponents
         modifiers[:sm] = true if @size == :small
         modifiers[:lg] = true if @size == :large
 
-        extras = [ @html_options[:class] ]
-        extras << "hakumi-spin-nested-loading" if nested?
-
-        class_names("spin", modifiers, extras)
+        classes = component_classes("spin", modifiers, @html_options)
+        nested? ? [ classes, "hakumi-spin-nested-loading" ].join(" ") : classes
       end
 
+      sig { returns(Types::DataAttributes) }
       def data_attributes
-        data = {
+        data = T.let({
           controller: "hakumi--spin",
           "hakumi--spin-spinning-value": @spinning
-        }
+        }, Types::DataAttributes)
 
         delay_value = normalized_delay
         data["hakumi--spin-delay-value"] = delay_value if delay_value.positive?
@@ -156,47 +196,68 @@ module HakumiComponents
         data
       end
 
+      sig { returns(Integer) }
       def normalized_delay
-        return 0 if @delay.nil?
-        return @delay if @delay.is_a?(Numeric)
-
-        @delay.to_s.strip.presence&.to_i || 0
+        @delay
       end
 
+      sig { returns(PercentInput) }
       def percent_value
         return nil unless progress?
         return "auto" if progress_auto?
 
-        @percent
+        numeric_percent
       end
 
+      sig { returns(T::Boolean) }
       def spinning_class?
         return false unless @spinning
 
         normalized_delay <= 0
       end
 
+      sig { returns(Types::RenderedContent) }
       def progress_indicator
         return default_indicator if progress_auto?
 
         render progress_component
       end
 
+      sig { returns(ActiveSupport::SafeBuffer) }
       def default_indicator
         tag.span(class: "hakumi-spin-dot", "aria-hidden": true) do
           safe_join(Array.new(4) { tag.span(class: "hakumi-spin-dot-item") })
         end
       end
 
+      sig { params(value: PercentInput).returns(ProgressPercent) }
       def normalize_percent(value)
         return nil if value.nil?
         return :auto if value == :auto || value.to_s.strip == "auto"
-        return value if value.is_a?(Numeric)
+        return value if value.is_a?(Integer)
+        return value if value.is_a?(Float)
 
         parsed = value.to_s.strip
         parsed.presence&.to_f
       end
 
+      sig { params(value: DelayInput).returns(Integer) }
+      def normalize_delay(value)
+        return 0 if value.nil?
+        return value if value.is_a?(Integer)
+        return value.to_i if value.is_a?(Float)
+
+        value.to_s.strip.presence&.to_i || 0
+      end
+
+      sig { returns(T.nilable(Numeric)) }
+      def numeric_percent
+        return nil unless @percent.is_a?(Numeric)
+
+        @percent
+      end
+
+      sig { returns(Integer) }
       def progress_size
         case @size
         when :small then 44

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

@@ -1,3 +1,9 @@
-<div <%= tag.attributes(html_attributes) %>>
-  <%= content %>
-</div>
+<%= tag.div(**wrapper_attributes) do %>
+  <% if panels.any? %>
+    <% panels.each do |panel| %>
+      <%= panel %>
+    <% end %>
+  <% else %>
+    <%= content %>
+  <% end %>
+<% end %>

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

@@ -1,37 +1,70 @@
+# typed: strict
+# frozen_string_literal: true
+
 module HakumiComponents
   module Splitter
     class Component < HakumiComponents::BaseComponent
+      extend T::Sig
+
+      LAYOUTS = T.let(%i[horizontal vertical].freeze, T::Array[Symbol])
+
+      renders_many :panels, ->(size: nil, min: nil, max: nil, resizable: true, collapsible: false, **options) do
+        T.bind(self, HakumiComponents::Splitter::Component)
+        HakumiComponents::Splitter::Panel::Component.new(
+          size: size,
+          min: min,
+          max: max,
+          resizable: resizable,
+          collapsible: collapsible,
+          layout: layout,
+          **options
+        )
+      end
+
+      sig do
+        params(
+          layout: Symbol,
+          resizable: T::Boolean,
+          html_options: Types::HtmlAttributeValue
+        ).void
+      end
       def initialize(layout: :horizontal, resizable: true, **html_options)
-        @layout = layout
-        @resizable = resizable
-        @html_options = html_options
+        @layout = T.let(layout, Symbol)
+        @resizable = T.let(resizable, T::Boolean)
+        @html_options = T.let(html_options, Types::HtmlAttributes)
+        validate_props!
       end
 
       private
 
-      def html_attributes
-        attrs = @html_options.dup
-        attrs[:class] = css_classes
-        attrs[:style] = inline_styles
-        attrs[:data] ||= {}
-        attrs[:data][:controller] = "hakumi--splitter"
-        attrs[:data][:hakumi__splitter_layout_value] = @layout.to_s
-        attrs[:data][:hakumi__splitter_resizable_value] = @resizable
-        attrs[:id] ||= generate_id("hakumi-splitter", length: 6)
-        attrs
+      sig { returns(Symbol) }
+      attr_reader :layout
+
+      sig { returns(String) }
+      def wrapper_classes
+        component_classes("splitter", { @layout => true }, @html_options)
       end
 
-      def css_classes
-        classes = [ "hakumi-splitter" ]
-        classes << "hakumi-splitter-#{@layout}"
-        classes << @html_options[:class] if @html_options[:class]
-        classes.join(" ")
+      sig { returns(Types::HtmlAttributes) }
+      def wrapper_attributes
+        existing_id = @html_options[:id]
+        id_value = existing_id.is_a?(String) ? existing_id : generate_id("hakumi-splitter", length: 6)
+
+        data = T.let({
+          controller: "hakumi--splitter",
+          hakumi__splitter_layout_value: @layout.to_s,
+          hakumi__splitter_resizable_value: @resizable
+        }, Types::DataAttributes)
+
+        merge_attributes(
+          { class: wrapper_classes, id: id_value, data: data },
+          @html_options.except(:class, :id)
+        )
       end
 
-      def inline_styles
-        styles = []
-        styles << @html_options[:style] if @html_options[:style]
-        styles.join("; ")
+      sig { void }
+      def validate_props!
+        validate_inclusion!(:layout, LAYOUTS)
       end
     end
   end

data/app/components/hakumi_components/splitter/panel/component.html.erb

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