hakumi_components 0.1.18.pre → 0.1.19.pre

data/app/components/hakumi_components/progress/controller_locals_parser.rb

@@ -0,0 +1,130 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Progress
+    class ControllerLocalsParser
+      extend T::Sig
+
+      DisplaySize = T.type_alias { T.nilable(BaseComponent::SizeValue) }
+      StrokeGradient = T.type_alias { T::Hash[String, String] }
+      StrokeColor = T.type_alias { T.nilable(T.any(String, StrokeGradient)) }
+      TooltipOptionsMap = T.type_alias { T::Hash[Types::HtmlKey, Types::HtmlPrimitive] }
+
+      class << self
+        extend T::Sig
+
+        sig { params(params: BaseComponent::ControllerOptions).returns(Types::HtmlAttributes) }
+        def call(params)
+          {
+            percent: parse_number(html_param(params, :percent)),
+            success_percent: parse_number(html_param(params, :success_percent)),
+            type: symbol_html_param(html_param(params, :type)),
+            status: symbol_html_param(html_param(params, :status)),
+            show_info: boolean_html_param(html_param(params, :show_info)),
+            size: parse_size(html_param(params, :size)),
+            stroke_width: parse_number(html_param(params, :stroke_width)),
+            stroke_color: parse_stroke_color(html_param(params, :stroke_color)),
+            trail_color: string_html_param(html_param(params, :trail_color)),
+            stroke_linecap: symbol_html_param(html_param(params, :stroke_linecap)),
+            steps: integer_html_param(html_param(params, :steps)),
+            gap_degree: parse_number(html_param(params, :gap_degree)),
+            gap_position: symbol_html_param(html_param(params, :gap_position)),
+            format: string_html_param(html_param(params, :format)),
+            info_tooltip: html_primitive_param(html_param(params, :info_tooltip)),
+            info_tooltip_threshold: parse_number(html_param(params, :info_tooltip_threshold)),
+            info_tooltip_options: parse_tooltip_options(html_param(params, :info_tooltip_options))
+          }.compact
+        end
+
+        private
+
+        sig { params(params: BaseComponent::ControllerOptions, key: Symbol).returns(Types::HtmlAttributeValue) }
+        def html_param(params, key)
+          BaseComponent.html_param(params, key)
+        end
+
+        sig { params(value: Types::HtmlAttributeValue).returns(Types::HtmlPrimitive) }
+        def html_primitive_param(value)
+          BaseComponent.html_primitive_param(value)
+        end
+
+        sig { params(value: Types::HtmlAttributeValue).returns(T.nilable(T::Boolean)) }
+        def boolean_html_param(value)
+          BaseComponent.boolean_html_param(value)
+        end
+
+        sig { params(value: Types::HtmlAttributeValue).returns(T.nilable(Symbol)) }
+        def symbol_html_param(value)
+          BaseComponent.symbol_html_param(value)
+        end
+
+        sig { params(value: Types::HtmlAttributeValue).returns(T.nilable(Integer)) }
+        def integer_html_param(value)
+          BaseComponent.integer_html_param(value)
+        end
+
+        sig { params(value: Types::HtmlAttributeValue).returns(T.nilable(String)) }
+        def string_html_param(value)
+          BaseComponent.string_html_param(value)
+        end
+
+        sig { params(value: Types::HtmlAttributeValue).returns(T.nilable(Float)) }
+        def parse_number(value)
+          return nil if value.nil?
+          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
+          nil
+        end
+
+        sig { params(value: Types::HtmlAttributeValue).returns(DisplaySize) }
+        def parse_size(value)
+          return nil if value.nil?
+          return value if value.is_a?(Integer)
+          return value.to_i if value.is_a?(Float)
+
+          if value.is_a?(String)
+            stripped = value.strip
+            return nil if stripped.empty?
+
+            size_name = stripped.to_sym
+            return size_name if Component::LINE_SIZES.include?(size_name)
+
+            return stripped.to_i
+          end
+
+          nil
+        end
+
+        sig { params(value: Types::HtmlAttributeValue).returns(StrokeColor) }
+        def parse_stroke_color(value)
+          return nil if value.nil?
+          return value if value.is_a?(String) && value.present?
+          return value.to_s if value.is_a?(Symbol)
+
+          return StrokeGradientValue.normalize(value, compact_blank: false) if value.is_a?(Hash)
+
+          nil
+        end
+
+        sig { params(value: Types::HtmlAttributeValue).returns(T.nilable(TooltipOptionsMap)) }
+        def parse_tooltip_options(value)
+          return nil unless value.is_a?(Hash)
+
+          options = T.let({}, TooltipOptionsMap)
+          value.each do |key, entry_value|
+            primitive = html_primitive_param(entry_value)
+            options[key] = primitive
+          end
+          options
+        end
+      end
+    end
+  end
+end

data/app/components/hakumi_components/progress/info_tooltip_policy.rb

@@ -0,0 +1,39 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Progress
+    class InfoTooltipPolicy
+      extend T::Sig
+
+      TooltipMode = T.type_alias { T.nilable(Symbol) }
+
+      sig { params(mode: TooltipMode, type: Symbol, circle_size: Integer, threshold: Integer).void }
+      def initialize(mode:, type:, circle_size:, threshold:)
+        @mode = T.let(mode, TooltipMode)
+        @type = T.let(type, Symbol)
+        @circle_size = T.let(circle_size, Integer)
+        @threshold = T.let(threshold, Integer)
+      end
+
+      sig { returns(T::Boolean) }
+      def enabled?
+        !@mode.nil?
+      end
+
+      sig { returns(T::Boolean) }
+      def wrap?
+        return false unless enabled?
+
+        case @mode
+        when :always
+          true
+        when :auto
+          @type == :circle && @circle_size <= @threshold
+        else
+          false
+        end
+      end
+    end
+  end
+end

data/app/components/hakumi_components/progress/info_value.rb

@@ -0,0 +1,75 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Progress
+    class InfoValue
+      extend T::Sig
+
+      ProgressValue = T.type_alias { Numeric }
+      FormatProc = T.type_alias do
+        T.proc.params(
+          percent: ProgressValue,
+          success_percent: T.nilable(ProgressValue)
+        ).returns(String)
+      end
+      FormatValue = T.type_alias { T.nilable(T.any(Types::Renderable, FormatProc)) }
+
+      sig do
+        params(
+          percent: ProgressValue,
+          success_percent: T.nilable(ProgressValue),
+          content: T.untyped,
+          format_value: FormatValue,
+          rendered_format: T.untyped
+        ).void
+      end
+      def initialize(percent:, success_percent:, content:, format_value:, rendered_format:)
+        @percent = T.let(percent, ProgressValue)
+        @success_percent = T.let(success_percent, T.nilable(ProgressValue))
+        @content = T.let(content, T.untyped)
+        @format_value = T.let(format_value, FormatValue)
+        @rendered_format = T.let(rendered_format, T.untyped)
+      end
+
+      sig { returns(T.untyped) }
+      def text
+        return @content if present?(@content)
+
+        format_value = @format_value
+        return format_value.call(@percent, @success_percent) if format_value.is_a?(Proc)
+        return @rendered_format if present?(@rendered_format)
+
+        percent_label
+      end
+
+      sig { returns(String) }
+      def tooltip_label
+        value = text
+        present?(value) ? value.to_s : percent_label
+      end
+
+      sig { returns(T::Boolean) }
+      def custom?
+        present?(@content) || !@format_value.nil?
+      end
+
+      sig { returns(String) }
+      def percent_label
+        whole_number?(@percent.to_f) ? "#{@percent.to_i}%" : "#{@percent}%"
+      end
+
+      private
+
+      sig { params(value: T.untyped).returns(T::Boolean) }
+      def present?(value)
+        value.respond_to?(:present?) ? value.present? : !value.nil?
+      end
+
+      sig { params(value: ProgressValue).returns(T::Boolean) }
+      def whole_number?(value)
+        (value.to_f % 1.0).zero?
+      end
+    end
+  end
+end

data/app/components/hakumi_components/progress/status_state.rb

@@ -0,0 +1,31 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Progress
+    class StatusState
+      extend T::Sig
+
+      ProgressValue = T.type_alias { Numeric }
+
+      sig { params(percent: ProgressValue, explicit_status: T.nilable(Symbol)).void }
+      def initialize(percent:, explicit_status:)
+        @percent = T.let(percent, ProgressValue)
+        @explicit_status = T.let(explicit_status, T.nilable(Symbol))
+      end
+
+      sig { returns(Symbol) }
+      def value
+        status = @explicit_status
+        return status unless status.nil?
+
+        @percent.to_f >= 100 ? :success : :normal
+      end
+
+      sig { returns(T::Boolean) }
+      def explicit?
+        !@explicit_status.nil?
+      end
+    end
+  end
+end

data/app/components/hakumi_components/progress/steps_renderer.rb

@@ -0,0 +1,149 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Progress
+    class StepsRenderer
+      extend T::Sig
+
+      ProgressValue = T.type_alias { Numeric }
+      StrokeGradient = T.type_alias { T::Hash[String, String] }
+      StrokeColor = T.type_alias { T.nilable(T.any(String, StrokeGradient)) }
+      StepStateValue = T.type_alias { Types::HtmlPrimitive }
+      StepState = T.type_alias { T::Hash[Symbol, StepStateValue] }
+
+      CIRCLE_STEP_GAP = T.let(2, Integer)
+
+      sig do
+        params(
+          type: Symbol,
+          percent: ProgressValue,
+          steps: T.nilable(Integer),
+          stroke_color: StrokeColor,
+          circle_geometry: T.nilable(CircleGeometry),
+          gradient_id: T.nilable(String)
+        ).void
+      end
+      def initialize(type:, percent:, steps:, stroke_color:, circle_geometry: nil, gradient_id: nil)
+        @type = T.let(type, Symbol)
+        @percent = T.let(percent, ProgressValue)
+        @steps = T.let(steps, T.nilable(Integer))
+        @stroke_color = T.let(stroke_color, StrokeColor)
+        @circle_geometry = T.let(circle_geometry, T.nilable(CircleGeometry))
+        @gradient_id = T.let(gradient_id, T.nilable(String))
+      end
+
+      sig { returns(T::Boolean) }
+      def circle_steps?
+        (circle? || dashboard?) && steps?
+      end
+
+      sig { returns(T::Array[StepState]) }
+      def line_steps
+        return [] unless line? && steps?
+
+        total = step_count
+        progress_units = (@percent.to_f / 100.0) * total
+
+        (0...total).map do |index|
+          {
+            active: progress_units > index,
+            current: index == progress_units.floor && progress_units < total,
+            width: "#{(100.0 / total).round(2)}%",
+            custom_color: line_custom_color
+          }
+        end
+      end
+
+      sig { returns(T::Array[StepState]) }
+      def circle_steps
+        return [] unless circle_steps?
+
+        geometry = @circle_geometry
+        return [] if geometry.nil?
+
+        total = step_count
+        effective = geometry.effective_length
+        segment_length = (effective - (CIRCLE_STEP_GAP * total)) / total.to_f
+        progress_units = (@percent.to_f / 100.0) * total
+        base_offset = format_float(geometry.dashoffset).to_f
+
+        (0...total).map do |index|
+          active = progress_units > index
+          current = index == progress_units.floor && progress_units < total
+          offset = base_offset + ((segment_length + CIRCLE_STEP_GAP) * index)
+          {
+            index: index,
+            active: active,
+            current: current,
+            dasharray: geometry.dasharray(segment_length),
+            dashoffset: format_float(offset),
+            stroke: circle_step_stroke(active)
+          }
+        end
+      end
+
+      private
+
+      sig { returns(T::Boolean) }
+      def line?
+        @type == :line
+      end
+
+      sig { returns(T::Boolean) }
+      def circle?
+        @type == :circle
+      end
+
+      sig { returns(T::Boolean) }
+      def dashboard?
+        @type == :dashboard
+      end
+
+      sig { returns(T::Boolean) }
+      def steps?
+        !@steps.nil? && @steps.positive?
+      end
+
+      sig { returns(Integer) }
+      def step_count
+        steps = @steps
+        return 0 if steps.nil?
+
+        steps
+      end
+
+      sig { returns(T.nilable(String)) }
+      def line_custom_color
+        color = @stroke_color
+        return nil unless color.is_a?(String)
+        return nil if color.empty?
+
+        color
+      end
+
+      sig { params(active: T::Boolean).returns(T.nilable(String)) }
+      def circle_step_stroke(active)
+        return "var(--hakumi-progress-trail-color, var(--color-border-secondary))" unless active
+
+        gradient_id = @gradient_id
+        return "url(##{gradient_id})" if gradient? && !gradient_id.nil?
+
+        color = @stroke_color
+        return color if color.is_a?(String) && !color.empty?
+
+        nil
+      end
+
+      sig { returns(T::Boolean) }
+      def gradient?
+        @stroke_color.is_a?(Hash)
+      end
+
+      sig { params(value: Float).returns(String) }
+      def format_float(value)
+        format("%.2f", value)
+      end
+    end
+  end
+end

data/app/components/hakumi_components/progress/stroke_gradient_value.rb

@@ -0,0 +1,90 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Progress
+    class StrokeGradientValue
+      extend T::Sig
+
+      StrokeGradient = T.type_alias { T::Hash[String, String] }
+      StrokeColor = T.type_alias { T.nilable(T.any(String, StrokeGradient)) }
+
+      sig { params(source: T::Hash[T.untyped, T.untyped], compact_blank: T::Boolean).returns(StrokeColor) }
+      def self.normalize(source, compact_blank: true)
+        gradient = T.let({}, StrokeGradient)
+        source.each do |key, value|
+          next if value.nil?
+
+          string_value = compact_blank ? value.to_s.strip : value.to_s
+          next if compact_blank && string_value.empty?
+
+          gradient[key.to_s] = string_value
+        end
+        gradient.empty? ? nil : gradient
+      end
+
+      sig { returns(Types::HtmlAttributes) }
+      def self.default_svg_direction
+        { x1: "0%", y1: "0%", x2: "100%", y2: "0%" }
+      end
+
+      sig { params(stops: T::Array[[ String, String ]]).returns(String) }
+      def self.stop_list(stops)
+        stops.map { |key, color| "#{color} #{key}" }.join(", ")
+      end
+
+      sig { params(source: StrokeGradient).void }
+      def initialize(source)
+        @source = T.let(source, StrokeGradient)
+      end
+
+      sig { returns(String) }
+      def direction
+        @source["direction"] || "to right"
+      end
+
+      sig { returns(T::Array[[ String, String ]]) }
+      def stop_pairs
+        entries = @source.reject { |key, value| key == "direction" || value.nil? }
+
+        if entries.key?("from") || entries.key?("to")
+          pairs = T.let([], T::Array[[ String, String ]])
+          from = entries["from"]
+          to = entries["to"]
+          pairs << [ "0%", from ] if from
+          pairs << [ "100%", to ] if to
+          return pairs
+        end
+
+        entries.map { |key, value| [ key, value ] }
+      end
+
+      sig { returns(T.nilable(String)) }
+      def css
+        stops = stop_pairs
+        return nil if stops.empty?
+
+        "linear-gradient(#{direction}, #{stop_list(stops)})"
+      end
+
+      sig { returns(Types::HtmlAttributes) }
+      def svg_direction
+        case direction
+        when "to left"
+          { x1: "100%", y1: "0%", x2: "0%", y2: "0%" }
+        when "to bottom"
+          { x1: "0%", y1: "0%", x2: "0%", y2: "100%" }
+        when "to top"
+          { x1: "0%", y1: "100%", x2: "0%", y2: "0%" }
+        else
+          self.class.default_svg_direction
+        end
+      end
+
+      sig { params(stops: T::Array[[ String, String ]]).returns(String) }
+      def stop_list(stops)
+        self.class.stop_list(stops)
+      end
+    end
+  end
+end