hakumi_components 0.1.18.pre → 0.1.19.pre

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

@@ -1,71 +1,96 @@
+# typed: strict
+# frozen_string_literal: true
+
 module HakumiComponents
   module Splitter
     module Panel
-      class Component < ViewComponent::Base
-        def initialize(size: nil, min: nil, max: nil, resizable: true, collapsible: false, **html_options)
-          @size = size
-          @min = min
-          @max = max
-          @resizable = resizable
-          @collapsible = collapsible
-          @html_options = html_options
+      class Component < HakumiComponents::BaseComponent
+        extend T::Sig
+
+        SizeInput = T.type_alias { BaseComponent::DimensionInput }
+        CollapsibleInput = T.type_alias { T.any(T::Boolean, Types::HtmlAttributes) }
+        CollapsibleValue = T.type_alias { T.any(T::Boolean, String) }
+
+        sig do
+          params(
+            size: SizeInput,
+            min: SizeInput,
+            max: SizeInput,
+            resizable: T::Boolean,
+            collapsible: CollapsibleInput,
+            layout: Symbol,
+            html_options: Types::HtmlAttributeValue
+          ).void
+        end
+        def initialize(size: nil, min: nil, max: nil, resizable: true, collapsible: false, layout: :horizontal, **html_options)
+          @size = T.let(size, SizeInput)
+          @min = T.let(min, SizeInput)
+          @max = T.let(max, SizeInput)
+          @resizable = T.let(resizable, T::Boolean)
+          @collapsible = T.let(collapsible, CollapsibleInput)
+          @layout = T.let(layout, Symbol)
+          @html_options = T.let(html_options, Types::HtmlAttributes)
         end
 
         private
 
-        def html_attributes
-          attrs = @html_options.dup
-          attrs[:class] = css_classes
-          attrs[:style] = inline_styles
-          attrs[:data] ||= {}
-          attrs[:data][:hakumi__splitter_target] = "panel"
-          attrs[:data][:hakumi__splitter_size_value] = @size.to_s if @size
-          attrs[:data][:hakumi__splitter_min_value] = @min.to_s if @min
-          attrs[:data][:hakumi__splitter_max_value] = @max.to_s if @max
-          attrs[:data][:hakumi__splitter_resizable_value] = @resizable
-          attrs[:data][:hakumi__splitter_collapsible_value] = collapsible_config
-          attrs
+        sig { returns(String) }
+        def wrapper_classes
+          component_classes("splitter-panel", {}, @html_options)
         end
 
-        def css_classes
-          classes = [ "hakumi-splitter-panel" ]
-          classes << @html_options[:class] if @html_options[:class]
-          classes.join(" ")
+        sig { returns(Types::HtmlAttributes) }
+        def wrapper_attributes
+          data = T.let({
+            hakumi__splitter_target: "panel",
+            hakumi__splitter_resizable_value: @resizable,
+            hakumi__splitter_collapsible_value: collapsible_config
+          }, Types::DataAttributes)
+          data[:hakumi__splitter_size_value] = @size.to_s if @size
+          data[:hakumi__splitter_min_value] = @min.to_s if @min
+          data[:hakumi__splitter_max_value] = @max.to_s if @max
+
+          merge_attributes(
+            { class: wrapper_classes, style: inline_styles, data: data },
+            @html_options.except(:class, :style)
+          )
         end
 
+        sig { returns(T.nilable(String)) }
         def inline_styles
-          styles = []
-
-          if @size
-            size_value = @size.is_a?(String) ? @size : "#{@size}px"
+          styles = T.let([], T::Array[String])
+          sz = @size
+          if sz
+            size_value = sz.is_a?(String) ? sz : "#{sz}px"
             styles << "flex: 0 0 #{size_value}"
             styles << "width: #{size_value}" if horizontal_layout?
             styles << "height: #{size_value}" if vertical_layout?
           else
             styles << "flex: 1"
           end
+          style_value = html_style(@html_options)
+          styles << style_value if style_value
 
-          styles << @html_options[:style] if @html_options[:style]
-          styles.join("; ")
+          styles.join("; ").presence
         end
 
+        sig { returns(CollapsibleValue) }
         def collapsible_config
-          return "false" unless @collapsible
+          c = @collapsible
+          return false unless c
+          return c.to_json if c.is_a?(Hash)
 
-          if @collapsible.is_a?(Hash)
-            @collapsible.to_json
-          else
-            "true"
-          end
+          true
         end
 
+        sig { returns(T::Boolean) }
         def horizontal_layout?
-          # This is a simplification - in real implementation we'd get this from parent
-          true
+          @layout == :horizontal
         end
 
+        sig { returns(T::Boolean) }
         def vertical_layout?
-          false
+          @layout == :vertical
         end
       end
     end

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

@@ -1,28 +1,46 @@
+# typed: strict
 # frozen_string_literal: true
 
 module HakumiComponents
   module Statistic
     class Component < HakumiComponents::BaseComponent
+      extend T::Sig
+
       include ActionView::Helpers::NumberHelper
 
-      DEFAULT_DURATION = 800
-      DEFAULT_COUNTDOWN_FORMAT = "HH:mm:ss"
+      Value = T.type_alias { T.nilable(T.any(Numeric, String, BaseComponent::DateLikeValue)) }
+      FormatValue = T.type_alias { T.nilable(String) }
+      PrecisionInput = T.type_alias { T.nilable(T.any(Integer, String)) }
+      DurationInput = T.type_alias { T.any(Numeric, String) }
+
+      DEFAULT_DURATION = T.let(800, Integer)
+      DEFAULT_COUNTDOWN_FORMAT = T.let("HH:mm:ss", String)
 
+      renders_one :title
+      renders_one :prefix
+      renders_one :suffix
+
+      sig do
+        params(
+          params: BaseComponent::ControllerOptions
+        ).returns(HakumiComponents::Types::HtmlAttributes)
+      end
       def self.extract_controller_locals(params)
         {
-          title: params[:title],
-          value: parse_value_param(params[:value]),
-          precision: parse_integer(params[:precision]),
-          prefix: params[:prefix],
-          suffix: params[:suffix],
-          animated: truthy_param?(params[:animated]),
-          duration: parse_number(params[:duration]),
-          countdown: truthy_param?(params[:countdown]),
-          format: params[:format],
-          aria_label: params[:aria_label]
+          title: html_primitive_param(html_param(params, :title)),
+          value: parse_value_param(html_param(params, :value)),
+          precision: parse_integer(html_param(params, :precision)),
+          prefix: html_primitive_param(html_param(params, :prefix)),
+          suffix: html_primitive_param(html_param(params, :suffix)),
+          animated: boolean_html_param(html_param(params, :animated)),
+          duration: parse_number(html_param(params, :duration)),
+          countdown: boolean_html_param(html_param(params, :countdown)),
+          format: html_primitive_param(html_param(params, :format)),
+          aria_label: html_primitive_param(html_param(params, :aria_label))
         }
       end
 
+      sig { params(value: Types::HtmlAttributeValue).returns(Value) }
       def self.parse_value_param(value)
         return nil if value.nil?
         return value if value.is_a?(Numeric)
@@ -32,33 +50,47 @@ module HakumiComponents
 
         Float(string_value)
       rescue ArgumentError
-        value
+        string_value
       end
 
+      sig { params(value: Types::HtmlAttributeValue).returns(T.nilable(Float)) }
       def self.parse_number(value)
         return nil if value.nil?
-        return value if value.is_a?(Numeric)
+        return value.to_f if value.is_a?(Numeric)
+        return nil unless value.is_a?(String)
 
-        Float(value) if value.to_s.strip != ""
+        Float(value) if value.strip != ""
       rescue ArgumentError
         nil
       end
 
+      sig { params(value: Types::HtmlAttributeValue).returns(T.nilable(Integer)) }
       def self.parse_integer(value)
         return nil if value.nil?
         return value if value.is_a?(Integer)
+        return value.to_i if value.is_a?(Float)
+        return nil unless value.is_a?(String)
 
-        Integer(value) if value.to_s.strip != ""
+        Integer(value) if value.strip != ""
       rescue ArgumentError
         nil
       end
 
-      def self.truthy_param?(value)
-        return value if value == true || value == false
-
-        value.to_s == "true"
+      sig do
+        params(
+          title: Types::Renderable,
+          value: Value,
+          precision: PrecisionInput,
+          prefix: Types::Renderable,
+          suffix: Types::Renderable,
+          animated: T::Boolean,
+          duration: DurationInput,
+          countdown: T::Boolean,
+          format: T.nilable(String),
+          aria_label: T.nilable(String),
+          html_options: Types::HtmlAttributeValue
+        ).void
       end
-
       def initialize(
         title: nil,
         value: nil,
@@ -72,21 +104,23 @@ module HakumiComponents
         aria_label: nil,
         **html_options
       )
-        @title = title
-        @value = value
-        @precision = normalize_precision(precision)
-        @prefix = prefix
-        @suffix = suffix
-        @animated = cast_boolean(animated)
-        @duration = normalize_duration(duration)
-        @countdown = cast_boolean(countdown)
-        @format = normalize_format(format)
-        @aria_label = normalize_string(aria_label)
-        @html_options = html_options
+        @title = T.let(title, Types::Renderable)
+        @value = T.let(value, Value)
+        @precision = T.let(normalize_precision(precision), T.nilable(Integer))
+        @prefix = T.let(prefix, Types::Renderable)
+        @suffix = T.let(suffix, Types::Renderable)
+        @animated = T.let(cast_boolean(animated) ? true : false, T::Boolean)
+        @duration = T.let(normalize_duration(duration), Float)
+        @countdown = T.let(cast_boolean(countdown) ? true : false, T::Boolean)
+        @format = T.let(normalize_format(format), T.nilable(String))
+        @aria_label = T.let(normalize_string(aria_label), T.nilable(String))
+        @html_options = T.let(html_options, Types::HtmlAttributes)
+        @numeric_value = T.let(resolve_numeric_value(@value), T.nilable(Float))
 
         validate_props!
       end
 
+      sig { returns(Types::HtmlAttributes) }
       def wrapper_attributes
         attrs = {
           class: wrapper_classes,
@@ -99,34 +133,48 @@ module HakumiComponents
         merge_attributes(attrs, @html_options)
       end
 
+      sig { returns(Types::RenderedContent) }
       def title_content
+        return render_value(title) if title?
+
         render_value(@title)
       end
 
+      sig { returns(Types::RenderedContent) }
       def prefix_content
+        return render_value(prefix) if prefix?
+
         render_value(@prefix)
       end
 
+      sig { returns(Types::RenderedContent) }
       def suffix_content
+        return render_value(suffix) if suffix?
+
         render_value(@suffix)
       end
 
+      sig { returns(Types::RenderedContent) }
       def display_value
-        return content if content.present?
+        block_content = content
+        return block_content if block_content.present?
         return formatted_countdown_value if countdown?
-        return formatted_numeric_value if numeric_value?
+        return formatted_numeric_value unless @numeric_value.nil?
 
-        render_value(@value).presence || "-"
+        fallback_display_value
       end
 
+      sig { returns(T::Boolean) }
       def countdown?
         @countdown
       end
 
+      sig { returns(T::Boolean) }
       def animated?
         @animated
       end
 
+      sig { returns(T.nilable(Integer)) }
       def countdown_target_timestamp
         return nil unless countdown?
 
@@ -136,20 +184,21 @@ module HakumiComponents
         (target.to_f * 1000).round
       end
 
+      sig { returns(T.nilable(String)) }
       def countdown_format
         return nil unless countdown?
 
         @format || DEFAULT_COUNTDOWN_FORMAT
       end
 
+      sig { returns(T.nilable(Float)) }
       def numeric_value
-        return nil unless numeric_value?
-
         @numeric_value
       end
 
       private
 
+      sig { void }
       def validate_props!
         if @precision && @precision.negative?
           raise ArgumentError, "precision must be greater than or equal to 0"
@@ -158,19 +207,21 @@ module HakumiComponents
         raise ArgumentError, "duration must be greater than 0" if @duration.to_f <= 0
       end
 
+      sig { returns(String) }
       def wrapper_classes
         modifiers = {
           countdown: countdown?
         }
 
-        class_names("statistic", modifiers, [ @html_options[:class] ])
+        component_classes("statistic", modifiers, @html_options)
       end
 
+      sig { returns(Types::DataAttributes) }
       def data_attributes
         {
           controller: "hakumi--statistic",
           "hakumi--statistic-animated-value": animated?,
-          "hakumi--statistic-duration-value": @duration,
+          "hakumi--statistic-duration-value": stimulus_duration_value,
           "hakumi--statistic-precision-value": @precision,
           "hakumi--statistic-countdown-value": countdown?,
           "hakumi--statistic-target-timestamp-value": countdown_target_timestamp,
@@ -179,22 +230,27 @@ module HakumiComponents
         }.compact
       end
 
+      sig { returns(String) }
       def formatted_numeric_value
-        value = numeric_value
+        value = @numeric_value
         return "-" if value.nil?
 
         if @precision
           number_with_precision(value, precision: @precision, delimiter: ",")
         else
+          return number_with_delimiter(value.to_i) if whole_number?(value)
+
           number_with_delimiter(value)
         end
       end
 
+      sig { returns(String) }
       def formatted_countdown_value
         remaining_ms = countdown_remaining_ms
         format_duration(remaining_ms, countdown_format || DEFAULT_COUNTDOWN_FORMAT)
       end
 
+      sig { returns(Integer) }
       def countdown_remaining_ms
         target = normalize_countdown_target(@value)
         return 0 unless target
@@ -203,37 +259,43 @@ module HakumiComponents
         remaining.positive? ? remaining.round : 0
       end
 
-      def numeric_value?
-        return @numeric_value if defined?(@numeric_value)
+      sig { params(value: Value).returns(T.nilable(Float)) }
+      def resolve_numeric_value(value)
+        return value.to_f if value.is_a?(Numeric)
+        return nil unless value.is_a?(String)
 
-        @numeric_value = begin
-          if @value.is_a?(Numeric)
-            @value
-          else
-            Float(@value)
-          end
-        rescue ArgumentError, TypeError
-          nil
-        end
+        stripped = value.strip
+        return nil if stripped.empty?
 
-        @numeric_value.present?
+        Float(stripped)
+      rescue ArgumentError, TypeError
+        nil
       end
 
+      sig { params(value: Value).returns(T.nilable(Time)) }
       def normalize_countdown_target(value)
         return nil if value.nil?
-        return value.to_time if value.respond_to?(:to_time)
+        return value if value.is_a?(Time)
+        return value.to_time if value.is_a?(Date) || value.is_a?(DateTime)
+        return Time.at(value.to_f) if value.is_a?(ActiveSupport::TimeWithZone)
 
         if value.is_a?(Numeric)
           seconds = value > 1_000_000_000_000 ? value / 1000.0 : value
           return Time.at(seconds)
         end
 
-        parsed = Time.zone ? Time.zone.parse(value.to_s) : Time.parse(value.to_s)
-        parsed
+        return nil unless value.is_a?(String)
+
+        tz = Time.zone
+        parsed = tz ? tz.parse(value.to_s) : Time.parse(value.to_s)
+        return nil if parsed.nil?
+
+        parsed.is_a?(ActiveSupport::TimeWithZone) ? Time.at(parsed.to_f) : parsed
       rescue ArgumentError, TypeError
         nil
       end
 
+      sig { params(milliseconds: Integer, format: String).returns(String) }
       def format_duration(milliseconds, format)
         total_seconds = (milliseconds.to_f / 1000).floor
         total_seconds = 0 if total_seconds.negative?
@@ -244,7 +306,7 @@ module HakumiComponents
         minutes = (total_seconds / 60) % 60
         seconds = total_seconds % 60
 
-        format_string = format || DEFAULT_COUNTDOWN_FORMAT
+        format_string = format
         use_days = format_string.include?("DD")
         hours_value = use_days ? hours : hours_total
 
@@ -255,6 +317,7 @@ module HakumiComponents
           .gsub("ss", seconds.to_s.rjust(2, "0"))
       end
 
+      sig { params(value: PrecisionInput).returns(T.nilable(Integer)) }
       def normalize_precision(value)
         return nil if value.nil?
         return value if value.is_a?(Integer)
@@ -264,24 +327,45 @@ module HakumiComponents
         raise ArgumentError, "precision must be an integer"
       end
 
+      sig { params(value: DurationInput).returns(Float) }
       def normalize_duration(value)
-        return DEFAULT_DURATION if value.nil?
-        return value if value.is_a?(Numeric)
+        return DEFAULT_DURATION.to_f if value.nil?
+        return value.to_f if value.is_a?(Numeric)
 
         Float(value)
       rescue ArgumentError, TypeError
         raise ArgumentError, "duration must be numeric"
       end
 
+      sig { params(value: T.nilable(String)).returns(T.nilable(String)) }
       def normalize_format(value)
-        value.to_s.strip.presence
+        value&.strip&.presence
       end
 
+      sig { params(value: T.nilable(Types::ValidationComparable)).returns(T.nilable(String)) }
       def normalize_string(value)
         return nil if value.nil?
 
         value.to_s.strip.presence
       end
+
+      sig { returns(String) }
+      def fallback_display_value
+        value = @value
+        return "-" if value.nil?
+
+        value.to_s.presence || "-"
+      end
+
+      sig { returns(Numeric) }
+      def stimulus_duration_value
+        whole_number?(@duration) ? @duration.to_i : @duration
+      end
+
+      sig { params(value: Float).returns(T::Boolean) }
+      def whole_number?(value)
+        (value % 1.0).zero?
+      end
     end
   end
 end