hakumi_components 0.1.17.pre → 0.1.19.pre

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

@@ -1,132 +0,0 @@
-# frozen_string_literal: true
-
-module Hakumi
-  module Popover
-    class Component < Hakumi::BaseComponent
-      PLACEMENTS = %w[
-        top topLeft topRight
-        bottom bottomLeft bottomRight
-        left leftTop leftBottom
-        right rightTop rightBottom
-        auto
-      ].freeze
-
-      TRIGGERS = %w[click hover focus].freeze
-
-      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])
-        }
-      end
-
-      def initialize(
-        title: nil,
-        body: nil,
-        trigger_body: nil,
-        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"]
-
-        validate_props!
-      end
-
-      def wrapper_classes
-        classes = [ "hakumi-popover-wrapper" ]
-        classes << "hakumi-popover-disabled" if @disabled
-        classes << @html_options[:class] if @html_options[:class]
-        classes.compact.join(" ")
-      end
-
-      def wrapper_id
-        @wrapper_id
-      end
-
-      def popover_dom_id
-        return if wrapper_id.blank?
-        "#{wrapper_id}-popover"
-      end
-
-      def popover_classes
-        classes = [ "hakumi-popover" ]
-        classes << "hakumi-popover-arrow-hidden" unless @arrow
-        classes.join(" ")
-      end
-
-      def data_attributes
-        data = {
-          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
-        }
-        data[:"hakumi--popover-open-value"] = @open unless @open.nil?
-        data
-      end
-
-      def trigger_content
-        content.presence || render_value(@trigger_body || @body)
-      end
-
-      def render_title
-        render_value(@title)
-      end
-
-      def render_popover_content
-        render_value(@body)
-      end
-
-      def has_title?
-        @title.present?
-      end
-
-      def has_popover_content?
-        @body.present?
-      end
-
-      private
-
-      def normalized_triggers
-        return [] if @trigger.nil?
-
-        triggers = @trigger.is_a?(Array) ? @trigger : @trigger.to_s.split(/[\s,]+/)
-        triggers.map(&:to_s).reject(&:empty?)
-      end
-
-      def validate_props!
-        validate_inclusion!(:placement, PLACEMENTS)
-
-        normalized_triggers.each do |trigger|
-          next if TRIGGERS.include?(trigger)
-
-          raise ArgumentError, "trigger must be one of #{TRIGGERS.inspect}, got #{trigger.inspect}"
-        end
-      end
-    end
-  end
-end

data/app/components/hakumi/progress/component.rb

@@ -1,565 +0,0 @@
-# frozen_string_literal: true
-
-module Hakumi
-  module Progress
-    class Component < Hakumi::BaseComponent
-      TYPES = [ :line, :circle, :dashboard ].freeze
-      STATUSES = [ :normal, :success, :exception, :active ].freeze
-      LINE_SIZES = [ :small, :default ].freeze
-      LINECAPS = [ :round, :square, :butt ].freeze
-      CIRCLE_STEP_GAP = 2
-
-      def self.extract_controller_locals(params)
-        {
-          percent: parse_number(params[:percent]),
-          success_percent: parse_number(params[:success_percent]),
-          type: params[:type]&.to_sym,
-          status: params[:status]&.to_sym,
-          show_info: params.key?(:show_info) ? ActiveModel::Type::Boolean.new.cast(params[:show_info]) : nil,
-          size: parse_size(params[:size]),
-          stroke_width: parse_number(params[:stroke_width]),
-          stroke_color: parse_stroke_color(params[:stroke_color]),
-          trail_color: params[:trail_color],
-          stroke_linecap: params[:stroke_linecap]&.to_sym,
-          steps: params[:steps].presence&.to_i,
-          gap_degree: parse_number(params[:gap_degree]),
-          gap_position: params[:gap_position]&.to_sym,
-          format: params[:format],
-          info_tooltip: params[:info_tooltip],
-          info_tooltip_threshold: parse_number(params[:info_tooltip_threshold]),
-          info_tooltip_options: params[:info_tooltip_options]
-        }
-      end
-
-      def self.parse_number(value)
-        return nil if value.nil?
-        return value if value.is_a?(Numeric)
-
-        value.to_f if value.to_s.strip != ""
-      end
-
-      def self.parse_size(value)
-        return nil if value.nil?
-        return value if value.is_a?(Numeric)
-
-        return value.to_sym if value.is_a?(String) && LINE_SIZES.include?(value.to_sym)
-
-        value.to_i if value.to_s.strip != ""
-      end
-
-      def self.parse_stroke_color(value)
-        return nil if value.nil?
-
-        return value.to_unsafe_h if value.respond_to?(:to_unsafe_h)
-        return value if value.is_a?(Hash)
-
-        value
-      end
-
-      def initialize(
-        percent: 0,
-        success_percent: nil,
-        type: :line,
-        status: nil,
-        show_info: true,
-        size: nil,
-        stroke_width: nil,
-        stroke_color: nil,
-        trail_color: nil,
-        stroke_linecap: :round,
-        steps: nil,
-        gap_degree: nil,
-        gap_position: nil,
-        format: nil,
-        info_tooltip: :auto,
-        info_tooltip_threshold: 20,
-        info_tooltip_options: {},
-        **html_options
-      )
-        @type = type
-        @status = status
-        @show_info = show_info.nil? ? true : show_info
-        @size = size
-        @stroke_width = stroke_width
-        @stroke_color = stroke_color
-        @trail_color = trail_color
-        @stroke_linecap = stroke_linecap
-        @steps = steps
-        @gap_degree = gap_degree
-        @gap_position = gap_position
-        @format = format
-        @html_options = html_options
-        @info_tooltip_mode = normalize_info_tooltip(info_tooltip)
-        @info_tooltip_threshold = info_tooltip_threshold
-        @info_tooltip_options = normalize_tooltip_options(info_tooltip_options)
-
-        @percent = clamp_percent(percent)
-        @success_percent = success_percent.nil? ? nil : clamp_percent(success_percent)
-
-        validate_props!
-      end
-
-      def wrapper_attributes
-        merge_attributes(
-          {
-            class: wrapper_classes,
-            role: "progressbar",
-            "aria-valuenow": @percent,
-            "aria-valuemin": 0,
-            "aria-valuemax": 100,
-            "aria-label": accessibility_label,
-            data: data_attributes
-          },
-          @html_options
-        )
-      end
-
-      def formatted_info
-        return nil unless show_info?
-        info_text
-      end
-
-      def show_info?
-        @show_info
-      end
-
-      def inline_info?
-        show_info? && !wrap_with_tooltip?
-      end
-
-      def wrap_with_tooltip?
-        return false unless tooltip_enabled?
-
-        case @info_tooltip_mode
-        when :always
-          true
-        when :auto
-          circle? && circle_size <= info_tooltip_threshold_value
-        else
-          false
-        end
-      end
-
-      def tooltip_component_options
-        options = (@info_tooltip_options || {}).dup
-        options[:title] ||= tooltip_label
-        options
-      end
-
-      def info_tooltip_threshold_value
-        (@info_tooltip_threshold || 20).to_i
-      end
-
-      def tooltip_label
-        info = show_info? ? formatted_info : nil
-        info.presence || "#{@percent.to_i}%"
-      end
-
-      def tooltip_enabled?
-        @info_tooltip_mode && @info_tooltip_mode != false
-      end
-
-      def line?
-        @type == :line
-      end
-
-      def circle?
-        @type == :circle
-      end
-
-      def dashboard?
-        @type == :dashboard
-      end
-
-      def steps?
-        @steps.to_i.positive?
-      end
-
-      def line_style
-        build_inline_style(
-          "--hakumi-progress-stroke-width" => "#{line_stroke_width}px",
-          "--hakumi-progress-trail-color" => @trail_color
-        )
-      end
-
-      def line_bar_style
-        styles = { "width" => "#{@percent}%" }
-        if gradient?
-          styles["background"] = gradient_css
-        elsif @stroke_color.present?
-          styles["background-color"] = @stroke_color
-        end
-        build_inline_style(styles)
-      end
-
-      def line_success_style
-        build_inline_style("width" => "#{@success_percent}%")
-      end
-
-      def line_steps
-        return [] unless line? && steps?
-
-        total = @steps.to_i
-        progress_units = (@percent / 100.0) * total
-        (0...total).map do |index|
-          active = progress_units > index
-          current = index == progress_units.floor && progress_units < total
-          {
-            active: active,
-            current: current,
-            width: "#{(100.0 / total).round(2)}%",
-            custom_color: steps_custom_color
-          }
-        end
-      end
-
-      def circle_size
-        return @size.to_i if @size.is_a?(Numeric)
-
-        120
-      end
-
-      def circle_inner_style
-        build_inline_style(
-          "width" => "#{circle_size}px",
-          "height" => "#{circle_size}px"
-        )
-      end
-
-      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
-
-      def circle_path_attributes
-        return {} if circle_steps?
-
-        attrs = {
-          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
-        }
-
-        attrs[:style] = build_inline_style("stroke" => circle_stroke) if circle_stroke
-        attrs
-      end
-
-      def circle_trail_style
-        build_inline_style("--hakumi-progress-trail-color" => @trail_color)
-      end
-
-      def circle_gradient_attributes
-        gradient_stops
-      end
-
-      def gradient_id
-        @gradient_id ||= generate_id("hakumi-progress-gradient")
-      end
-
-      def circle_stroke
-        return "url(##{gradient_id})" if gradient?
-        return @stroke_color if @stroke_color.present?
-
-        nil
-      end
-
-      def gradient?
-        @stroke_color.is_a?(Hash)
-      end
-
-      def gradient_css
-        data = gradient_stops
-        return nil unless data
-
-        "linear-gradient(#{data[:direction]}, #{gradient_stop_list(data[:stops])})"
-      end
-
-      def gradient_svg_direction
-        data = gradient_stops
-        return { x1: "0%", y1: "0%", x2: "100%", y2: "0%" } unless data
-
-        direction = data[: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
-          { x1: "0%", y1: "0%", x2: "100%", y2: "0%" }
-        end
-      end
-
-      def status
-        return @status if @status
-
-        @percent >= 100 ? :success : :normal
-      end
-
-      def data_attributes
-        {
-          controller: "hakumi--progress",
-          "hakumi--progress-type-value": @type,
-          "hakumi--progress-percent-value": @percent,
-          "hakumi--progress-success-percent-value": @success_percent,
-          "hakumi--progress-status-value": status,
-          "hakumi--progress-status-explicit-value": @status.present?,
-          "hakumi--progress-steps-value": @steps,
-          "hakumi--progress-gap-degree-value": @gap_degree,
-          "hakumi--progress-gap-position-value": circle_gap_position,
-          "hakumi--progress-stroke-width-value": stroke_width_value,
-          "hakumi--progress-show-info-value": show_info?,
-          "hakumi--progress-custom-info-value": custom_info?
-        }
-      end
-
-      private
-
-      def info_text
-        return content if content.present?
-
-        if @format.respond_to?(:call)
-          value = @format.call(@percent, @success_percent)
-          return render_value(value)
-        end
-
-        rendered_format = render_value(@format)
-        return rendered_format if rendered_format.present?
-
-        "#{@percent.to_i}%"
-      end
-
-      def validate_props!
-        validate_inclusion!(:type, TYPES)
-        validate_inclusion!(:status, STATUSES)
-        validate_inclusion!(:stroke_linecap, LINECAPS)
-
-        if line? && @size.is_a?(Symbol)
-          validate_inclusion!(:size, LINE_SIZES)
-        end
-
-        if (circle? || dashboard?) && @size.is_a?(Symbol)
-          raise ArgumentError, "size must be numeric for circle or dashboard"
-        end
-      end
-
-      def wrapper_classes
-        modifiers = {
-          @type => true,
-          "status-#{status}" => true,
-          "show-info" => show_info?,
-          "linecap-#{@stroke_linecap}" => true
-        }
-
-        modifiers[:small] = true if line? && @size == :small
-        modifiers[:steps] = true if steps?
-
-        class_names("progress", modifiers, [ @html_options[:class] ])
-      end
-
-      def accessibility_label
-        "Progress #{@percent.to_i}%"
-      end
-
-      def clamp_percent(value)
-        value = value.to_f
-        return 0 if value.nan?
-
-        clamped = value.clamp(0, 100)
-        clamped == clamped.to_i ? clamped.to_i : clamped
-      end
-
-      def line_stroke_width
-        return @stroke_width if @stroke_width
-
-        return 6 if @size == :small
-
-        8
-      end
-
-      def steps_custom_color
-        return @stroke_color if @stroke_color.present? && !gradient?
-
-        nil
-      end
-
-      def circle_stroke_width
-        stroke_width_value
-      end
-
-      def circle_radius
-        50 - (circle_stroke_width / 2.0)
-      end
-
-      def circle_total_length
-        2 * Math::PI * circle_radius
-      end
-
-      def circle_gap_degree
-        return @gap_degree if @gap_degree
-
-        dashboard? ? 75 : 0
-      end
-
-      def circle_gap_position
-        return @gap_position if @gap_position
-
-        dashboard? ? :bottom : :top
-      end
-
-      def circle_gap_length
-        circle_total_length * (circle_gap_degree / 360.0)
-      end
-
-      def circle_effective_length
-        circle_total_length - circle_gap_length
-      end
-
-      def circle_path_length
-        circle_effective_length * (@percent / 100.0)
-      end
-
-      def circle_trail_length
-        circle_effective_length
-      end
-
-      def circle_dashoffset
-        format_float(circle_gap_length / 2.0)
-      end
-
-      def circle_path_dasharray
-        "#{format_float(circle_path_length)} #{format_float(circle_total_length)}"
-      end
-
-      def circle_trail_dasharray
-        "#{format_float(circle_trail_length)} #{format_float(circle_total_length)}"
-      end
-
-      def circle_transform
-        "rotate(#{circle_rotation} 50 50)"
-      end
-
-      def circle_rotation
-        case circle_gap_position
-        when :left then 180
-        when :right then 0
-        when :bottom then 90
-        else -90
-        end
-      end
-
-      def format_float(value)
-        format("%.2f", value)
-      end
-
-      def gradient_stops
-        return nil unless gradient?
-
-        raw = @stroke_color.transform_keys(&:to_s)
-        direction = raw.delete("direction") || "to right"
-
-        stops = if raw.key?("from") || raw.key?("to")
-          [ [ "0%", raw["from"] ], [ "100%", raw["to"] ] ].compact
-        else
-          raw.map { |key, val| [ key, val ] }
-        end
-
-        stops = stops.reject { |_key, val| val.nil? }
-        return nil if stops.empty?
-
-        { direction: direction, stops: stops }
-      end
-
-      def gradient_stop_list(stops)
-        stops.map { |key, color| "#{color} #{key}" }.join(", ")
-      end
-
-      def stroke_width_value
-        return @stroke_width if @stroke_width
-
-        circle? || dashboard? ? 6 : line_stroke_width
-      end
-
-      def custom_info?
-        content.present? || @format.present?
-      end
-
-      def circle_steps?
-        (circle? || dashboard?) && steps?
-      end
-
-      def circle_steps
-        return [] unless circle_steps?
-
-        total = @steps.to_i
-        gap = circle_step_gap
-        effective = circle_effective_length
-        segment_length = (effective - (gap * total)) / total.to_f
-        progress_units = (@percent / 100.0) * total
-
-        (0...total).map do |index|
-          active = progress_units > index
-          current = index == progress_units.floor && progress_units < total
-          offset = circle_dashoffset.to_f + ((segment_length + gap) * index)
-          {
-            index: index,
-            active: active,
-            current: current,
-            dasharray: "#{format_float(segment_length)} #{format_float(circle_total_length)}",
-            dashoffset: format_float(offset),
-            stroke: circle_step_stroke(active)
-          }
-        end
-      end
-
-      def circle_step_gap
-        CIRCLE_STEP_GAP
-      end
-
-      def circle_step_stroke(active)
-        return "var(--hakumi-progress-trail-color, var(--color-border-secondary))" unless active
-        return "url(##{gradient_id})" if gradient?
-        return @stroke_color if @stroke_color.present?
-
-        nil
-      end
-
-      def normalize_info_tooltip(value)
-        string_value = value.is_a?(String) ? value.strip.downcase : value
-
-        return :always if string_value == :always || string_value == "always"
-        return :auto if string_value == :auto || string_value.nil?
-
-        ActiveModel::Type::Boolean.new.cast(value) ? :auto : false
-      end
-
-      def normalize_tooltip_options(value)
-        options = value || {}
-        options = options.to_unsafe_h if options.respond_to?(:to_unsafe_h)
-        options = options.to_h unless options.is_a?(Hash)
-        options.deep_symbolize_keys! if options.respond_to?(:deep_symbolize_keys)
-        options
-      end
-    end
-  end
-end