hakumi_components 0.1.17.pre → 0.1.19.pre

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

@@ -1,209 +0,0 @@
-# frozen_string_literal: true
-
-module Hakumi
-  module Spin
-    class Component < Hakumi::BaseComponent
-      SIZES = [ :small, :default, :large ].freeze
-
-      def self.extract_controller_locals(params)
-        {
-          spinning: params.key?(:spinning) ? ActiveModel::Type::Boolean.new.cast(params[:spinning]) : true,
-          size: params[:size]&.to_sym,
-          tip: params[:tip],
-          delay: parse_delay(params[:delay]),
-          fullscreen: ActiveModel::Type::Boolean.new.cast(params[:fullscreen]),
-          percent: parse_percent(params[:percent])
-        }
-      end
-
-      def self.parse_delay(value)
-        return nil if value.nil?
-        return value if value.is_a?(Numeric)
-
-        value.to_s.strip.presence&.to_i
-      end
-
-      def self.parse_percent(value)
-        return nil if value.nil?
-
-        string_value = value.to_s.strip
-        return :auto if string_value == "auto"
-
-        return value if value.is_a?(Numeric)
-
-        string_value.presence&.to_f
-      end
-
-      def initialize(
-        spinning: true,
-        size: :default,
-        tip: nil,
-        delay: 0,
-        indicator: nil,
-        fullscreen: false,
-        percent: nil,
-        **html_options
-      )
-        @spinning = ActiveModel::Type::Boolean.new.cast(spinning)
-        @size = (size || :default).to_sym
-        @tip = tip
-        @delay = delay
-        @indicator = indicator
-        @fullscreen = fullscreen
-        @percent = normalize_percent(percent)
-        @html_options = html_options
-
-        validate_props!
-      end
-
-      def wrapper_attributes
-        merge_attributes(
-          {
-            class: wrapper_classes,
-            role: "status",
-            "aria-live": "polite",
-            "aria-busy": @spinning,
-            data: data_attributes
-          },
-          @html_options
-        )
-      end
-
-      def nested?
-        content? && !@fullscreen
-      end
-
-      def indicator_markup
-        return render_value(@indicator) if @indicator.present?
-        return progress_indicator if progress?
-
-        default_indicator
-      end
-
-      def tip_markup
-        render_value(@tip)
-      end
-
-      def show_text?
-        @tip.present?
-      end
-
-      def progress?
-        !@percent.nil?
-      end
-
-      def progress_auto?
-        @percent == :auto
-      end
-
-      def progress_component
-        Hakumi::Progress::Component.new(
-          percent: @percent,
-          type: :circle,
-          size: progress_size,
-          stroke_width: 6,
-          show_info: true
-        )
-      end
-
-      private
-
-      def validate_props!
-        validate_inclusion!(:size, SIZES)
-
-        delay_value = normalized_delay
-        raise ArgumentError, "delay must be a non-negative number" if delay_value.negative?
-
-        return unless progress?
-        return if progress_auto?
-
-        unless @percent.is_a?(Numeric)
-          raise ArgumentError, "percent must be numeric or :auto"
-        end
-
-        @percent = @percent.clamp(0, 100)
-      end
-
-      def wrapper_classes
-        modifiers = {
-          spinning: spinning_class?,
-          "show-text": show_text?,
-          fullscreen: @fullscreen,
-          standalone: !nested?,
-          progress: progress?,
-          "progress-auto": progress_auto?
-        }
-
-        modifiers[:sm] = true if @size == :small
-        modifiers[:lg] = true if @size == :large
-
-        extras = [ @html_options[:class] ]
-        extras << "hakumi-spin-nested-loading" if nested?
-
-        class_names("spin", modifiers, extras)
-      end
-
-      def data_attributes
-        data = {
-          controller: "hakumi--spin",
-          "hakumi--spin-spinning-value": @spinning
-        }
-
-        delay_value = normalized_delay
-        data["hakumi--spin-delay-value"] = delay_value if delay_value.positive?
-        data["hakumi--spin-percent-value"] = percent_value if percent_value
-
-        data
-      end
-
-      def normalized_delay
-        return 0 if @delay.nil?
-        return @delay if @delay.is_a?(Numeric)
-
-        @delay.to_s.strip.presence&.to_i || 0
-      end
-
-      def percent_value
-        return nil unless progress?
-        return "auto" if progress_auto?
-
-        @percent
-      end
-
-      def spinning_class?
-        return false unless @spinning
-
-        normalized_delay <= 0
-      end
-
-      def progress_indicator
-        return default_indicator if progress_auto?
-
-        render progress_component
-      end
-
-      def default_indicator
-        tag.span(class: "hakumi-spin-dot", "aria-hidden": true) do
-          safe_join(Array.new(4) { tag.span(class: "hakumi-spin-dot-item") })
-        end
-      end
-
-      def normalize_percent(value)
-        return nil if value.nil?
-        return :auto if value == :auto || value.to_s.strip == "auto"
-        return value if value.is_a?(Numeric)
-
-        parsed = value.to_s.strip
-        parsed.presence&.to_f
-      end
-
-      def progress_size
-        case @size
-        when :small then 44
-        when :large then 84
-        else 64
-        end
-      end
-    end
-  end
-end

data/app/components/hakumi/splitter/component.html.erb

@@ -1,3 +0,0 @@
-<div <%= tag.attributes(html_attributes) %>>
-  <%= content %>
-</div>

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

@@ -1,38 +0,0 @@
-module Hakumi
-  module Splitter
-    class Component < Hakumi::BaseComponent
-      def initialize(layout: :horizontal, resizable: true, **html_options)
-        @layout = layout
-        @resizable = resizable
-        @html_options = html_options
-      end
-
-      private
-
-      def html_attributes
-        attrs = @html_options.dup
-        attrs[:class] = css_classes
-        attrs[:style] = inline_styles
-        attrs[:data] ||= {}
-        attrs[:data][:controller] = "hakumi--splitter"
-        attrs[:data][:hakumi__splitter_layout_value] = @layout.to_s
-        attrs[:data][:hakumi__splitter_resizable_value] = @resizable
-        attrs[:id] ||= generate_id("hakumi-splitter", length: 6)
-        attrs
-      end
-
-      def css_classes
-        classes = [ "hakumi-splitter" ]
-        classes << "hakumi-splitter-#{@layout}"
-        classes << @html_options[:class] if @html_options[:class]
-        classes.join(" ")
-      end
-
-      def inline_styles
-        styles = []
-        styles << @html_options[:style] if @html_options[:style]
-        styles.join("; ")
-      end
-    end
-  end
-end

data/app/components/hakumi/splitter/panel/component.html.erb

@@ -1,3 +0,0 @@
-<div <%= tag.attributes(html_attributes) %>>
-  <%= content %>
-</div>

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

@@ -1,73 +0,0 @@
-module Hakumi
-  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
-        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
-        end
-
-        def css_classes
-          classes = [ "hakumi-splitter-panel" ]
-          classes << @html_options[:class] if @html_options[:class]
-          classes.join(" ")
-        end
-
-        def inline_styles
-          styles = []
-
-          if @size
-            size_value = @size.is_a?(String) ? @size : "#{@size}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
-
-          styles << @html_options[:style] if @html_options[:style]
-          styles.join("; ")
-        end
-
-        def collapsible_config
-          return "false" unless @collapsible
-
-          if @collapsible.is_a?(Hash)
-            @collapsible.to_json
-          else
-            "true"
-          end
-        end
-
-        def horizontal_layout?
-          # This is a simplification - in real implementation we'd get this from parent
-          true
-        end
-
-        def vertical_layout?
-          false
-        end
-      end
-    end
-  end
-end

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

@@ -1,287 +0,0 @@
-# frozen_string_literal: true
-
-module Hakumi
-  module Statistic
-    class Component < Hakumi::BaseComponent
-      include ActionView::Helpers::NumberHelper
-
-      DEFAULT_DURATION = 800
-      DEFAULT_COUNTDOWN_FORMAT = "HH:mm:ss"
-
-      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]
-        }
-      end
-
-      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
-        value
-      end
-
-      def self.parse_number(value)
-        return nil if value.nil?
-        return value if value.is_a?(Numeric)
-
-        Float(value) if value.to_s.strip != ""
-      rescue ArgumentError
-        nil
-      end
-
-      def self.parse_integer(value)
-        return nil if value.nil?
-        return value if value.is_a?(Integer)
-
-        Integer(value) if value.to_s.strip != ""
-      rescue ArgumentError
-        nil
-      end
-
-      def self.truthy_param?(value)
-        return value if value == true || value == false
-
-        value.to_s == "true"
-      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 = 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
-
-        validate_props!
-      end
-
-      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
-
-      def title_content
-        render_value(@title)
-      end
-
-      def prefix_content
-        render_value(@prefix)
-      end
-
-      def suffix_content
-        render_value(@suffix)
-      end
-
-      def display_value
-        return content if content.present?
-        return formatted_countdown_value if countdown?
-        return formatted_numeric_value if numeric_value?
-
-        render_value(@value).presence || "-"
-      end
-
-      def countdown?
-        @countdown
-      end
-
-      def animated?
-        @animated
-      end
-
-      def countdown_target_timestamp
-        return nil unless countdown?
-
-        target = normalize_countdown_target(@value)
-        return nil unless target
-
-        (target.to_f * 1000).round
-      end
-
-      def countdown_format
-        return nil unless countdown?
-
-        @format || DEFAULT_COUNTDOWN_FORMAT
-      end
-
-      def numeric_value
-        return nil unless numeric_value?
-
-        @numeric_value
-      end
-
-      private
-
-      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
-
-      def wrapper_classes
-        modifiers = {
-          countdown: countdown?
-        }
-
-        class_names("statistic", modifiers, [ @html_options[:class] ])
-      end
-
-      def data_attributes
-        {
-          controller: "hakumi--statistic",
-          "hakumi--statistic-animated-value": animated?,
-          "hakumi--statistic-duration-value": @duration,
-          "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
-
-      def formatted_numeric_value
-        value = numeric_value
-        return "-" if value.nil?
-
-        if @precision
-          number_with_precision(value, precision: @precision, delimiter: ",")
-        else
-          number_with_delimiter(value)
-        end
-      end
-
-      def formatted_countdown_value
-        remaining_ms = countdown_remaining_ms
-        format_duration(remaining_ms, countdown_format || DEFAULT_COUNTDOWN_FORMAT)
-      end
-
-      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
-
-      def numeric_value?
-        return @numeric_value if defined?(@numeric_value)
-
-        @numeric_value = begin
-          if @value.is_a?(Numeric)
-            @value
-          else
-            Float(@value)
-          end
-        rescue ArgumentError, TypeError
-          nil
-        end
-
-        @numeric_value.present?
-      end
-
-      def normalize_countdown_target(value)
-        return nil if value.nil?
-        return value.to_time if value.respond_to?(:to_time)
-
-        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
-      rescue ArgumentError, TypeError
-        nil
-      end
-
-      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 || DEFAULT_COUNTDOWN_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
-
-      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
-
-      def normalize_duration(value)
-        return DEFAULT_DURATION if value.nil?
-        return value if value.is_a?(Numeric)
-
-        Float(value)
-      rescue ArgumentError, TypeError
-        raise ArgumentError, "duration must be numeric"
-      end
-
-      def normalize_format(value)
-        value.to_s.strip.presence
-      end
-
-      def normalize_string(value)
-        return nil if value.nil?
-
-        value.to_s.strip.presence
-      end
-    end
-  end
-end