hakumi_components 0.1.18.pre → 0.1.19.pre

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

@@ -1,123 +1,187 @@
+# typed: strict
 # frozen_string_literal: true
 
 module HakumiComponents
   module Popover
     class Component < HakumiComponents::BaseComponent
-      PLACEMENTS = %w[
+      extend T::Sig
+
+      Placement = T.type_alias { T.any(Symbol, String) }
+      TriggerValue = T.type_alias { T.any(Symbol, String, T::Array[T.any(Symbol, String)]) }
+
+      PLACEMENTS = T.let(%i[
         top topLeft topRight
         bottom bottomLeft bottomRight
         left leftTop leftBottom
         right rightTop rightBottom
         auto
-      ].freeze
+      ].freeze, T::Array[Symbol])
 
-      TRIGGERS = %w[click hover focus].freeze
+      TRIGGERS = T.let(%i[click hover focus].freeze, T::Array[Symbol])
 
+      sig do
+        params(
+          params: T.any(ActionController::Parameters, HakumiComponents::Types::HtmlAttributes)
+        ).returns(HakumiComponents::Types::HtmlAttributes)
+      end
       def self.extract_controller_locals(params)
         {
-          title: params[:title],
-          body: params[:body],
-          trigger_body: params[:trigger_body],
-          placement: params[:placement],
-          trigger: params[:trigger],
-          open: ActiveModel::Type::Boolean.new.cast(params[:open]),
-          arrow: params[:arrow].nil? ? true : ActiveModel::Type::Boolean.new.cast(params[:arrow]),
-          disabled: ActiveModel::Type::Boolean.new.cast(params[:disabled]),
-          auto_adjust_overflow: params[:auto_adjust_overflow].nil? ? true : ActiveModel::Type::Boolean.new.cast(params[:auto_adjust_overflow])
+          title: html_primitive_param(html_param(params, :title)),
+          body: html_primitive_param(html_param(params, :body)),
+          trigger_body: html_primitive_param(html_param(params, :trigger_body)),
+          placement: symbol_html_param(html_param(params, :placement)),
+          trigger: trigger_param(html_param(params, :trigger)),
+          open: boolean_html_param(html_param(params, :open)),
+          arrow: html_param(params, :arrow).nil? ? true : boolean_html_param(html_param(params, :arrow)),
+          disabled: boolean_html_param(html_param(params, :disabled)),
+          auto_adjust_overflow: html_param(params, :auto_adjust_overflow).nil? ? true : boolean_html_param(html_param(params, :auto_adjust_overflow))
         }
       end
 
+      sig do
+        params(
+          title: HakumiComponents::Types::Renderable,
+          body: HakumiComponents::Types::Renderable,
+          trigger_body: HakumiComponents::Types::Renderable,
+          placement: Placement,
+          trigger: T.nilable(TriggerValue),
+          open: T.nilable(T::Boolean),
+          arrow: T::Boolean,
+          disabled: T::Boolean,
+          auto_adjust_overflow: T::Boolean,
+          html_options: HakumiComponents::Types::HtmlAttributeValue
+        ).void
+      end
       def initialize(
         title: nil,
         body: nil,
         trigger_body: nil,
-        placement: "top",
-        trigger: "hover",
+        placement: :top,
+        trigger: :hover,
         open: nil,
         arrow: true,
         disabled: false,
         auto_adjust_overflow: true,
         **html_options
       )
-        @title = title
-        @body = body
-        @trigger_body = trigger_body
-        @placement = placement
-        @trigger = trigger
-        @open = open
-        @arrow = arrow
-        @disabled = disabled
-        @auto_adjust_overflow = auto_adjust_overflow
-        @html_options = html_options
-        @wrapper_id = html_options[:id] || html_options["id"]
+        @title = T.let(title, HakumiComponents::Types::Renderable)
+        @body = T.let(body, HakumiComponents::Types::Renderable)
+        @trigger_body = T.let(trigger_body, HakumiComponents::Types::Renderable)
+        @placement = T.let(placement.to_sym, Symbol)
+        @trigger = T.let(trigger, T.nilable(TriggerValue))
+        @open = T.let(open, T.nilable(T::Boolean))
+        @arrow = T.let(arrow, T::Boolean)
+        @disabled = T.let(disabled, T::Boolean)
+        @auto_adjust_overflow = T.let(auto_adjust_overflow, T::Boolean)
+        @html_options = T.let(html_options, HakumiComponents::Types::HtmlAttributes)
+        raw_wrapper_id = @html_options[:id]
+        @wrapper_id = T.let(raw_wrapper_id&.to_s, T.nilable(String))
 
         validate_props!
       end
 
+      sig { returns(String) }
       def wrapper_classes
-        classes = [ "hakumi-popover-wrapper" ]
-        classes << "hakumi-popover-disabled" if @disabled
-        classes << @html_options[:class] if @html_options[:class]
-        classes.compact.join(" ")
+        extras = T.let([], T::Array[T.nilable(String)])
+        extras << "hakumi-popover-disabled" if @disabled
+        extras.concat(Array(html_classes(@html_options)).compact)
+
+        class_names(
+          "popover-wrapper",
+          {},
+          extras
+        )
       end
 
+      sig { returns(T.nilable(String)) }
       def wrapper_id
         @wrapper_id
       end
 
+      sig { returns(T.nilable(String)) }
       def popover_dom_id
         return if wrapper_id.blank?
         "#{wrapper_id}-popover"
       end
 
+      sig { returns(String) }
       def popover_classes
-        classes = [ "hakumi-popover" ]
-        classes << "hakumi-popover-arrow-hidden" unless @arrow
-        classes.join(" ")
+        class_names("popover", { "arrow-hidden": !@arrow })
       end
 
+      sig { returns(HakumiComponents::Types::DataAttributes) }
       def data_attributes
-        data = {
+        data = T.let({
           controller: "hakumi--popover",
           "hakumi--popover-placement-value": @placement,
           "hakumi--popover-trigger-value": normalized_triggers.join(","),
           "hakumi--popover-disabled-value": @disabled,
           "hakumi--popover-arrow-value": @arrow,
           "hakumi--popover-auto-adjust-overflow-value": @auto_adjust_overflow
-        }
+        }, HakumiComponents::Types::DataAttributes)
         data[:"hakumi--popover-open-value"] = @open unless @open.nil?
+        existing = @html_options[:data]
+        existing.each { |key, value| data[key] = value } if existing.is_a?(Hash)
         data
       end
 
+      sig { returns(HakumiComponents::Types::Renderable) }
       def trigger_content
         content.presence || render_value(@trigger_body || @body)
       end
 
+      sig { returns(HakumiComponents::Types::Renderable) }
       def render_title
         render_value(@title)
       end
 
+      sig { returns(HakumiComponents::Types::Renderable) }
       def render_popover_content
         render_value(@body)
       end
 
-      def has_title?
+      sig { returns(T::Boolean) }
+      def title_present?
         @title.present?
       end
 
-      def has_popover_content?
+      sig { returns(T::Boolean) }
+      def popover_content?
         @body.present?
       end
 
       private
 
+      class << self
+        extend T::Sig
+
+        private
+
+        sig { params(value: HakumiComponents::Types::HtmlAttributeValue).returns(T.nilable(TriggerValue)) }
+        def trigger_param(value)
+          return value if value.is_a?(String) || value.is_a?(Symbol)
+
+          entries = string_or_symbol_array_html_param(value)
+          return entries unless entries.nil?
+
+          nil
+        end
+      end
+
+      sig { returns(T::Array[Symbol]) }
       def normalized_triggers
         return [] if @trigger.nil?
 
-        triggers = @trigger.is_a?(Array) ? @trigger : @trigger.to_s.split(/[\s,]+/)
-        triggers.map(&:to_s).reject(&:empty?)
+        if @trigger.is_a?(Array)
+          @trigger.map { |t| t.to_s.to_sym }
+        elsif @trigger.is_a?(Symbol)
+          [ @trigger ]
+        else
+          @trigger.to_s.split(/[\s,]+/).map(&:to_sym).reject { |t| t == :"" }
+        end
       end
 
+      sig { void }
       def validate_props!
         validate_inclusion!(:placement, PLACEMENTS)
 

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

@@ -0,0 +1,354 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Progress
+    class AttributeRenderer
+      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)) }
+      DisplaySize = T.type_alias { T.nilable(BaseComponent::SizeValue) }
+      StepStateValue = T.type_alias { Types::HtmlPrimitive }
+      StepState = T.type_alias { T::Hash[Symbol, StepStateValue] }
+      StyleBuilder = T.type_alias { T.proc.params(styles: T.nilable(Types::StyleValue)).returns(T.nilable(String)) }
+
+      sig do
+        params(
+          type: Symbol,
+          percent: ProgressValue,
+          success_percent: T.nilable(ProgressValue),
+          size: DisplaySize,
+          stroke_width: T.nilable(Float),
+          stroke_color: StrokeColor,
+          trail_color: T.nilable(String),
+          stroke_linecap: Symbol,
+          steps: T.nilable(Integer),
+          gap_degree: T.nilable(Float),
+          gap_position: T.nilable(Symbol),
+          gradient_id: String,
+          style_builder: StyleBuilder
+        ).void
+      end
+      def initialize(
+        type:,
+        percent:,
+        success_percent:,
+        size:,
+        stroke_width:,
+        stroke_color:,
+        trail_color:,
+        stroke_linecap:,
+        steps:,
+        gap_degree:,
+        gap_position:,
+        gradient_id:,
+        style_builder:
+      )
+        @type = T.let(type, Symbol)
+        @percent = T.let(percent, ProgressValue)
+        @success_percent = T.let(success_percent, T.nilable(ProgressValue))
+        @size = T.let(size, DisplaySize)
+        @stroke_width = T.let(stroke_width, T.nilable(Float))
+        @stroke_color = T.let(stroke_color, StrokeColor)
+        @trail_color = T.let(trail_color, T.nilable(String))
+        @stroke_linecap = T.let(stroke_linecap, Symbol)
+        @steps = T.let(steps, T.nilable(Integer))
+        @gap_degree = T.let(gap_degree, T.nilable(Float))
+        @gap_position = T.let(gap_position, T.nilable(Symbol))
+        @gradient_id = T.let(gradient_id, String)
+        @style_builder = T.let(style_builder, StyleBuilder)
+        @circle_geometry = T.let(nil, T.nilable(Progress::CircleGeometry))
+        @stroke_gradient = T.let(nil, T.nilable(Progress::StrokeGradientValue))
+      end
+
+      sig { returns(T.nilable(String)) }
+      def line_style
+        style(
+          "--hakumi-progress-stroke-width" => "#{line_stroke_width}px",
+          "--hakumi-progress-trail-color" => @trail_color
+        )
+      end
+
+      sig { returns(T.nilable(String)) }
+      def line_bar_style
+        styles = T.let({ "width" => "#{@percent}%" }, Types::StyleMap)
+        if gradient?
+          styles["background"] = gradient_css
+        elsif @stroke_color.is_a?(String)
+          styles["background-color"] = @stroke_color
+        end
+        style(styles)
+      end
+
+      sig { returns(T.nilable(String)) }
+      def line_success_style
+        success = @success_percent
+        return nil if success.nil?
+
+        style("width" => "#{success}%")
+      end
+
+      sig { returns(T::Array[StepState]) }
+      def line_steps
+        steps_renderer.line_steps
+      end
+
+      sig { returns(Integer) }
+      def circle_size
+        return @size if @size.is_a?(Integer)
+
+        120
+      end
+
+      sig { returns(T.nilable(String)) }
+      def circle_inner_style
+        style(
+          "width" => "#{circle_size}px",
+          "height" => "#{circle_size}px"
+        )
+      end
+
+      sig { returns(Types::HtmlAttributes) }
+      def circle_trail_attributes
+        return {} if circle_steps?
+
+        {
+          class: "hakumi-progress-circle-trail",
+          cx: 50,
+          cy: 50,
+          r: circle_radius,
+          fill: "none",
+          stroke: "var(--hakumi-progress-trail-color, var(--color-border-secondary))",
+          "stroke-width": circle_stroke_width,
+          "stroke-dasharray": circle_trail_dasharray,
+          "stroke-dashoffset": circle_dashoffset,
+          transform: circle_transform
+        }
+      end
+
+      sig { returns(Types::HtmlAttributes) }
+      def circle_path_attributes
+        return {} if circle_steps?
+
+        attrs = T.let(
+          {
+            class: "hakumi-progress-circle-path",
+            cx: 50,
+            cy: 50,
+            r: circle_radius,
+            fill: "none",
+            "stroke-linecap": @stroke_linecap,
+            "stroke-width": circle_stroke_width,
+            "stroke-dasharray": circle_path_dasharray,
+            "stroke-dashoffset": circle_dashoffset,
+            transform: circle_transform
+          },
+          Types::HtmlAttributes
+        )
+
+        stroke = circle_stroke
+        attrs[:style] = style("stroke" => stroke) if stroke
+        attrs
+      end
+
+      sig { returns(T.nilable(String)) }
+      def circle_trail_style
+        style("--hakumi-progress-trail-color" => @trail_color)
+      end
+
+      sig { returns(T::Array[[ String, String ]]) }
+      def circle_gradient_attributes
+        gradient = gradient_value
+        return [] if gradient.nil?
+
+        gradient.stop_pairs
+      end
+
+      sig { returns(String) }
+      attr_reader :gradient_id
+
+      sig { returns(Types::HtmlAttributes) }
+      def gradient_svg_direction
+        gradient = gradient_value
+        return Progress::StrokeGradientValue.default_svg_direction if gradient.nil?
+
+        gradient.svg_direction
+      end
+
+      sig { returns(T::Boolean) }
+      def gradient?
+        @stroke_color.is_a?(Hash)
+      end
+
+      sig { returns(T.nilable(String)) }
+      def gradient_css
+        gradient = gradient_value
+        return nil if gradient.nil?
+
+        gradient.css
+      end
+
+      sig { returns(Float) }
+      def circle_stroke_width
+        stroke_width_value.to_f
+      end
+
+      sig { returns(Float) }
+      def circle_radius
+        circle_geometry.radius
+      end
+
+      sig { returns(String) }
+      def circle_transform
+        circle_geometry.transform
+      end
+
+      sig { returns(T::Boolean) }
+      def circle_steps?
+        steps_renderer.circle_steps?
+      end
+
+      sig { returns(T::Array[StepState]) }
+      def circle_steps
+        steps_renderer(
+          circle_geometry: circle_geometry,
+          gradient_id: gradient? ? gradient_id : nil
+        ).circle_steps
+      end
+
+      sig { params(step: StepState).returns(T.nilable(String)) }
+      def circle_step_style(step)
+        stroke = step[:stroke]
+        style("stroke" => stroke&.to_s)
+      end
+
+      sig { returns(Symbol) }
+      def circle_gap_position
+        return @gap_position unless @gap_position.nil?
+
+        dashboard? ? :bottom : :top
+      end
+
+      sig { returns(ProgressValue) }
+      def stroke_width_value
+        return whole_number?(@stroke_width) ? @stroke_width.to_i : @stroke_width unless @stroke_width.nil?
+
+        return 6 if circle? || dashboard?
+
+        width = line_stroke_width
+        whole_number?(width) ? width.to_i : width
+      end
+
+      sig { returns(Progress::CircleGeometry) }
+      def circle_geometry
+        geometry = @circle_geometry
+        return geometry unless geometry.nil?
+
+        geometry = Progress::CircleGeometry.new(
+          stroke_width: circle_stroke_width,
+          gap_degree: circle_gap_degree,
+          gap_position: circle_gap_position
+        )
+        @circle_geometry = geometry
+      end
+
+      private
+
+      sig { params(styles: T.nilable(Types::StyleValue)).returns(T.nilable(String)) }
+      def style(styles)
+        @style_builder.call(styles)
+      end
+
+      sig { returns(T::Boolean) }
+      def circle?
+        @type == :circle
+      end
+
+      sig { returns(T::Boolean) }
+      def dashboard?
+        @type == :dashboard
+      end
+
+      sig { returns(Float) }
+      def line_stroke_width
+        return @stroke_width unless @stroke_width.nil?
+        return 6.0 if @size == :small
+
+        8.0
+      end
+
+      sig { returns(T.nilable(String)) }
+      def circle_stroke
+        return "url(##{gradient_id})" if gradient?
+        return @stroke_color if @stroke_color.is_a?(String) && @stroke_color.present?
+
+        nil
+      end
+
+      sig { returns(Float) }
+      def circle_gap_degree
+        return @gap_degree unless @gap_degree.nil?
+
+        dashboard? ? 75.0 : 0.0
+      end
+
+      sig { returns(String) }
+      def circle_dashoffset
+        format_float(circle_geometry.dashoffset)
+      end
+
+      sig { returns(String) }
+      def circle_path_dasharray
+        circle_geometry.dasharray(circle_geometry.path_length(@percent))
+      end
+
+      sig { returns(String) }
+      def circle_trail_dasharray
+        circle_geometry.dasharray(circle_geometry.effective_length)
+      end
+
+      sig { params(value: Float).returns(String) }
+      def format_float(value)
+        format("%.2f", value)
+      end
+
+      sig { returns(T.nilable(Progress::StrokeGradientValue)) }
+      def gradient_value
+        gradient = @stroke_gradient
+        return gradient unless gradient.nil?
+
+        value = @stroke_color
+        return nil unless value.is_a?(Hash)
+
+        gradient = Progress::StrokeGradientValue.new(value)
+        @stroke_gradient = gradient
+      end
+
+      sig do
+        params(
+          circle_geometry: T.nilable(Progress::CircleGeometry),
+          gradient_id: T.nilable(String)
+        ).returns(Progress::StepsRenderer)
+      end
+      def steps_renderer(circle_geometry: nil, gradient_id: nil)
+        Progress::StepsRenderer.new(
+          type: @type,
+          percent: @percent,
+          steps: @steps,
+          stroke_color: @stroke_color,
+          circle_geometry: circle_geometry,
+          gradient_id: gradient_id
+        )
+      end
+
+      sig { params(value: T.nilable(Float)).returns(T::Boolean) }
+      def whole_number?(value)
+        return false if value.nil?
+
+        (value.to_f % 1.0).zero?
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Progress
+    class CircleGeometry
+      extend T::Sig
+
+      ProgressValue = T.type_alias { Numeric }
+
+      sig { params(stroke_width: Float, gap_degree: Float, gap_position: Symbol).void }
+      def initialize(stroke_width:, gap_degree:, gap_position:)
+        @stroke_width = T.let(stroke_width, Float)
+        @gap_degree = T.let(gap_degree, Float)
+        @gap_position = T.let(gap_position, Symbol)
+      end
+
+      sig { returns(Float) }
+      def radius
+        50 - (@stroke_width / 2.0)
+      end
+
+      sig { returns(Float) }
+      def total_length
+        2 * Math::PI * radius
+      end
+
+      sig { returns(Float) }
+      def gap_length
+        total_length * (@gap_degree / 360.0)
+      end
+
+      sig { returns(Float) }
+      def effective_length
+        total_length - gap_length
+      end
+
+      sig { params(percent: ProgressValue).returns(Float) }
+      def path_length(percent)
+        effective_length * (percent.to_f / 100.0)
+      end
+
+      sig { returns(Float) }
+      def dashoffset
+        gap_length / 2.0
+      end
+
+      sig { params(length: Float).returns(String) }
+      def dasharray(length)
+        "#{format_float(length)} #{format_float(total_length)}"
+      end
+
+      sig { returns(String) }
+      def transform
+        "rotate(#{rotation} 50 50)"
+      end
+
+      sig { returns(Integer) }
+      def rotation
+        case @gap_position
+        when :left then 180
+        when :right then 0
+        when :bottom then 90
+        else -90
+        end
+      end
+
+      private
+
+      sig { params(value: Float).returns(String) }
+      def format_float(value)
+        format("%.2f", value)
+      end
+    end
+  end
+end