hakumi_components 0.1.17.pre → 0.1.19.pre

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

@@ -0,0 +1,371 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Statistic
+    class Component < HakumiComponents::BaseComponent
+      extend T::Sig
+
+      include ActionView::Helpers::NumberHelper
+
+      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: 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)
+
+        string_value = value.to_s.strip
+        return nil if string_value.empty?
+
+        Float(string_value)
+      rescue ArgumentError
+        string_value
+      end
+
+      sig { params(value: Types::HtmlAttributeValue).returns(T.nilable(Float)) }
+      def self.parse_number(value)
+        return nil if value.nil?
+        return value.to_f if value.is_a?(Numeric)
+        return nil unless value.is_a?(String)
+
+        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.strip != ""
+      rescue ArgumentError
+        nil
+      end
+
+      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,
+        precision: nil,
+        prefix: nil,
+        suffix: nil,
+        animated: false,
+        duration: DEFAULT_DURATION,
+        countdown: false,
+        format: nil,
+        aria_label: nil,
+        **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,
+          role: countdown? ? "timer" : "status",
+          "aria-live": countdown? || animated? ? "polite" : nil,
+          "aria-label": @aria_label,
+          data: data_attributes
+        }
+
+        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
+        block_content = content
+        return block_content if block_content.present?
+        return formatted_countdown_value if countdown?
+        return formatted_numeric_value unless @numeric_value.nil?
+
+        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?
+
+        target = normalize_countdown_target(@value)
+        return nil unless target
+
+        (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
+        @numeric_value
+      end
+
+      private
+
+      sig { void }
+      def validate_props!
+        if @precision && @precision.negative?
+          raise ArgumentError, "precision must be greater than or equal to 0"
+        end
+
+        raise ArgumentError, "duration must be greater than 0" if @duration.to_f <= 0
+      end
+
+      sig { returns(String) }
+      def wrapper_classes
+        modifiers = {
+          countdown: countdown?
+        }
+
+        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": stimulus_duration_value,
+          "hakumi--statistic-precision-value": @precision,
+          "hakumi--statistic-countdown-value": countdown?,
+          "hakumi--statistic-target-timestamp-value": countdown_target_timestamp,
+          "hakumi--statistic-format-value": countdown_format,
+          "hakumi--statistic-value-value": numeric_value
+        }.compact
+      end
+
+      sig { returns(String) }
+      def formatted_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
+
+        remaining = (target.to_f - Time.current.to_f) * 1000
+        remaining.positive? ? remaining.round : 0
+      end
+
+      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)
+
+        stripped = value.strip
+        return nil if stripped.empty?
+
+        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 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
+
+        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?
+
+        days = total_seconds / 86_400
+        hours_total = total_seconds / 3_600
+        hours = hours_total % 24
+        minutes = (total_seconds / 60) % 60
+        seconds = total_seconds % 60
+
+        format_string = format
+        use_days = format_string.include?("DD")
+        hours_value = use_days ? hours : hours_total
+
+        format_string
+          .gsub("DD", days.to_s.rjust(2, "0"))
+          .gsub("HH", hours_value.to_s.rjust(2, "0"))
+          .gsub("mm", minutes.to_s.rjust(2, "0"))
+          .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)
+
+        Integer(value)
+      rescue ArgumentError, TypeError
+        raise ArgumentError, "precision must be an integer"
+      end
+
+      sig { params(value: DurationInput).returns(Float) }
+      def normalize_duration(value)
+        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&.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

data/app/components/{hakumi → hakumi_components}/steps/component.html.erb

@@ -10,15 +10,15 @@
             <span class="hakumi-steps-icon hakumi-steps-icon-dot"></span>
           <% elsif item.icon %>
             <span class="hakumi-steps-icon">
-              <%= render Hakumi::Icon::Component.new(name: item.icon, spin: item.icon_spin) %>
+              <%= render HakumiComponents::Icon::Component.new(name: item.icon, spin: item.icon_spin) %>
             </span>
           <% elsif computed_status == :finish %>
             <span class="hakumi-steps-icon">
-              <%= render Hakumi::Icon::Component.new(name: :check) %>
+              <%= render HakumiComponents::Icon::Component.new(name: :check) %>
             </span>
           <% elsif computed_status == :error %>
             <span class="hakumi-steps-icon">
-              <%= render Hakumi::Icon::Component.new(name: :close) %>
+              <%= render HakumiComponents::Icon::Component.new(name: :close) %>
             </span>
           <% else %>
             <span class="hakumi-steps-icon"><%= index + 1 %></span>
@@ -46,7 +46,7 @@
         </div>
       <% end %>
       <% if item.tooltip.present? %>
-        <%= render Hakumi::Tooltip::Component.new(title: item.tooltip) do %>
+        <%= render HakumiComponents::Tooltip::Component.new(title: item.tooltip) do %>
           <div class="hakumi-steps-item-container"><%= container_content %></div>
         <% end %>
       <% else %>

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

@@ -0,0 +1,177 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Steps
+    class Component < HakumiComponents::BaseComponent
+      extend T::Sig
+
+      DIRECTIONS = T.let(%i[horizontal vertical].freeze, T::Array[Symbol])
+      TYPES = T.let(%i[default navigation inline].freeze, T::Array[Symbol])
+      SIZES = T.let(%i[default small].freeze, T::Array[Symbol])
+      STATUSES = T.let(%i[wait process finish error].freeze, T::Array[Symbol])
+      LABEL_PLACEMENTS = T.let(%i[horizontal vertical].freeze, T::Array[Symbol])
+      VARIANTS = T.let(%i[filled outlined].freeze, T::Array[Symbol])
+
+      renders_many :items, ->(
+        title: nil,
+        subtitle: nil,
+        description: nil,
+        tooltip: nil,
+        icon: nil,
+        icon_spin: false,
+        status: nil,
+        disabled: false,
+        **options
+      ) do
+        HakumiComponents::Steps::Item::Component.new(
+          title: title,
+          subtitle: subtitle,
+          description: description,
+          tooltip: tooltip,
+          icon: icon,
+          icon_spin: icon_spin,
+          status: status,
+          disabled: disabled,
+          parent: self,
+          **options
+        )
+      end
+
+      sig do
+        params(
+          current: Integer,
+          direction: Symbol,
+          type: Symbol,
+          size: Symbol,
+          status: Symbol,
+          label_placement: T.nilable(Symbol),
+          percent: T.nilable(Numeric),
+          progress_dot: T::Boolean,
+          responsive: T::Boolean,
+          initial: Integer,
+          clickable: T::Boolean,
+          variant: Symbol,
+          html_options: Types::HtmlAttributeValue
+        ).void
+      end
+      def initialize(
+        current: 0,
+        direction: :horizontal,
+        type: :default,
+        size: :default,
+        status: :process,
+        label_placement: nil,
+        percent: nil,
+        progress_dot: false,
+        responsive: true,
+        initial: 0,
+        clickable: false,
+        variant: :filled,
+        **html_options
+      )
+        @current = T.let(current, Integer)
+        @direction = T.let(direction, Symbol)
+        @type = T.let(type, Symbol)
+        @size = T.let(size, Symbol)
+        @status = T.let(status, Symbol)
+        @label_placement = T.let(label_placement, T.nilable(Symbol))
+        @percent = T.let(percent, T.nilable(Numeric))
+        @progress_dot = T.let(progress_dot, T::Boolean)
+        @responsive = T.let(responsive, T::Boolean)
+        @initial = T.let(initial, Integer)
+        @clickable = T.let(clickable, T::Boolean)
+        @variant = T.let(variant, Symbol)
+        @html_options = T.let(html_options, Types::HtmlAttributes)
+
+        validate_props!
+      end
+
+      sig { returns(Integer) }
+      attr_reader :current, :initial
+
+      sig { returns(Symbol) }
+      attr_reader :direction, :type, :size, :status, :variant
+
+      sig { returns(T.nilable(Symbol)) }
+      attr_reader :label_placement
+
+      sig { returns(T.nilable(Numeric)) }
+      attr_reader :percent
+
+      sig { returns(T::Boolean) }
+      attr_reader :progress_dot, :responsive, :clickable
+
+      sig { returns(String) }
+      def steps_classes
+        modifiers = T.let({
+          direction => true,
+          type => @type != :default,
+          small: @size == :small,
+          "label-#{effective_label_placement}": @direction == :horizontal && @type == :default,
+          "with-progress": @percent.present?,
+          dot: @progress_dot,
+          navigation: @type == :navigation,
+          inline: @type == :inline,
+          variant => @variant != :filled
+        }, Types::ClassModifiers)
+        component_classes("steps", modifiers, @html_options)
+      end
+
+      sig { returns(Symbol) }
+      def effective_label_placement
+        return :vertical if @progress_dot && @direction == :horizontal
+
+        @label_placement || :horizontal
+      end
+
+      sig { returns(Types::HtmlAttributes) }
+      def wrapper_attributes
+        data = stimulus_attrs("hakumi--steps", T.let({
+          current: @current,
+          clickable: @clickable
+        }, Types::StimulusValues))
+        merge_attributes({ class: steps_classes, data: data }, @html_options.except(:class))
+      end
+
+      sig { params(index: Integer).returns(Symbol) }
+      def item_status(index)
+        raw_item = items[index]
+        if raw_item && raw_item.respond_to?(:status)
+          s = raw_item.status
+          return s if s
+        end
+
+        if index < @current
+          :finish
+        elsif index == @current
+          @status
+        else
+          :wait
+        end
+      end
+
+      sig { params(index: Integer).returns(T::Boolean) }
+      def item_clickable?(index)
+        return false unless @clickable
+
+        raw_item = items[index]
+        return false unless raw_item && raw_item.respond_to?(:disabled)
+
+        !raw_item.disabled
+      end
+
+      private
+
+      sig { void }
+      def validate_props!
+        validate_inclusion!(:direction, DIRECTIONS)
+        validate_inclusion!(:type, TYPES)
+        validate_inclusion!(:size, SIZES)
+        validate_inclusion!(:status, STATUSES)
+        validate_inclusion!(:label_placement, LABEL_PLACEMENTS) if @label_placement
+        validate_inclusion!(:variant, VARIANTS)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,130 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Steps
+    module Item
+      class Component < HakumiComponents::BaseComponent
+        extend T::Sig
+
+        STATUSES = T.let(%i[wait process finish error].freeze, T::Array[Symbol])
+
+        sig do
+          params(
+            title: T.nilable(Types::Renderable),
+            subtitle: T.nilable(String),
+            description: T.nilable(Types::Renderable),
+            tooltip: T.nilable(String),
+            icon: T.nilable(T.any(Symbol, ViewComponent::Base)),
+            icon_spin: T::Boolean,
+            status: T.nilable(Symbol),
+            disabled: T::Boolean,
+            parent: T.nilable(HakumiComponents::Steps::Component),
+            html_options: Types::HtmlAttributeValue
+          ).void
+        end
+        def initialize(
+          title: nil,
+          subtitle: nil,
+          description: nil,
+          tooltip: nil,
+          icon: nil,
+          icon_spin: false,
+          status: nil,
+          disabled: false,
+          parent: nil,
+          **html_options
+        )
+          @title = T.let(title, T.nilable(Types::Renderable))
+          @subtitle = T.let(subtitle, T.nilable(String))
+          @description = T.let(description, T.nilable(Types::Renderable))
+          @tooltip = T.let(tooltip, T.nilable(String))
+          @icon = T.let(icon, T.nilable(T.any(Symbol, ViewComponent::Base)))
+          @icon_spin = T.let(icon_spin, T::Boolean)
+          @status = T.let(status, T.nilable(Symbol))
+          @disabled = T.let(disabled, T::Boolean)
+          @parent = T.let(parent, T.nilable(HakumiComponents::Steps::Component))
+          @html_options = T.let(html_options, Types::HtmlAttributes)
+
+          validate_props!
+        end
+
+        sig { returns(T.nilable(Types::Renderable)) }
+        attr_reader :title, :description
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :subtitle, :tooltip
+
+        sig { returns(T.nilable(T.any(Symbol, ViewComponent::Base))) }
+        attr_reader :icon
+
+        sig { returns(T::Boolean) }
+        attr_reader :icon_spin, :disabled
+
+        sig { returns(T.nilable(Symbol)) }
+        attr_reader :status
+
+        sig { params(computed_status: Symbol, clickable: T::Boolean).returns(String) }
+        def item_classes(computed_status, clickable)
+          classes = T.let([ "hakumi-steps-item" ], T::Array[String])
+          classes << "hakumi-steps-item-#{computed_status}"
+          classes << "hakumi-steps-item-disabled" if @disabled
+          classes << "hakumi-steps-item-clickable" if clickable && !@disabled
+          classes << "hakumi-steps-item-custom" if @icon
+          classes.join(" ")
+        end
+
+        sig { params(index: Integer, computed_status: Symbol, clickable: T::Boolean).returns(Types::HtmlAttributes) }
+        def wrapper_attributes(index, computed_status, clickable)
+          base_attrs = T.let({ class: item_classes(computed_status, clickable) }, Types::HtmlAttributes)
+
+          if clickable && !@disabled
+            base_attrs[:data] = T.let({
+              action: "click->hakumi--steps#selectStep",
+              "step-index" => index
+            }, Types::DataAttributes)
+          end
+
+          merge_attributes(base_attrs, @html_options)
+        end
+
+        sig do
+          params(
+            computed_status: Symbol,
+            index: Integer,
+            progress_dot: T::Boolean,
+            percent: T.nilable(Numeric)
+          ).returns(T.nilable(T.any(Symbol, ViewComponent::Base)))
+        end
+        def icon_content(computed_status, index, progress_dot, percent)
+          return nil if progress_dot
+
+          if @icon
+            @icon
+          else
+            case computed_status
+            when :finish
+              :check
+            when :error
+              :close
+            end
+          end
+        end
+
+        sig { params(computed_status: Symbol).returns(T::Boolean) }
+        def show_number?(computed_status)
+          return false if @icon
+
+          %i[wait process].include?(computed_status)
+        end
+
+        private
+
+        sig { void }
+        def validate_props!
+          validate_inclusion!(:status, STATUSES) if @status
+        end
+      end
+    end
+  end
+end