hakumi_components 0.1.17.pre → 0.1.19.pre

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

@@ -1,269 +0,0 @@
-# frozen_string_literal: true
-
-module Hakumi
-  module Segmented
-    class Component < Hakumi::BaseComponent
-      SIZES = [ :small, :middle, :large ].freeze
-
-      def self.extract_controller_locals(params)
-        options = params[:options]
-        options = params[:options_json] if options.nil?
-        options = parse_options_param(options)
-
-        {
-          options: options,
-          value: params[:value],
-          default_value: params[:default_value],
-          disabled: truthy_param?(params[:disabled]),
-          block: truthy_param?(params[:block]),
-          vertical: truthy_param?(params[:vertical]),
-          round: truthy_param?(params[:round]),
-          name: params[:name],
-          size: params[:size],
-          aria_label: params[:aria_label]
-        }.compact
-      end
-
-      def initialize(
-        options: [],
-        value: nil,
-        default_value: nil,
-        disabled: false,
-        block: false,
-        vertical: false,
-        round: false,
-        name: nil,
-        size: :middle,
-        aria_label: nil,
-        **html_options
-      )
-        @options = normalize_options(options)
-        @value = normalize_value(value, default_value)
-        @value = @options.first[:value]&.to_s if @value.nil? && @options.any?
-        @disabled = cast_boolean(disabled)
-        @block = cast_boolean(block)
-        @vertical = cast_boolean(vertical)
-        @round = cast_boolean(round)
-        @name = normalize_string(name) || generate_id("segmented")
-        @size = normalize_size(size) || :middle
-        @aria_label = normalize_string(aria_label)
-        @html_options = html_options
-
-        validate_props!
-      end
-
-      def wrapper_attributes
-        attrs = {
-          class: wrapper_classes,
-          role: "radiogroup",
-          "aria-disabled": @disabled ? "true" : nil,
-          "aria-orientation": @vertical ? "vertical" : nil,
-          "aria-label": @aria_label,
-          data: data_attributes
-        }
-
-        merge_attributes(attrs, @html_options.except(:class))
-      end
-
-      def normalized_options
-        @options
-      end
-
-      def option_classes(option)
-        class_names(
-          "segmented-item",
-          {
-            selected: option_selected?(option),
-            disabled: option_disabled?(option)
-          },
-          [
-            option[:class_name],
-            ("hakumi-segmented-item-icon-only" if icon_only_option?(option))
-          ]
-        )
-      end
-
-      def option_data_attributes(option)
-        {
-          "hakumi--segmented-target": "item",
-          value: option[:value].to_s,
-          label: option[:label].is_a?(String) ? option[:label] : nil,
-          disabled: option_disabled?(option) ? "true" : nil
-        }.compact
-      end
-
-      def option_input_attributes(option, index)
-        attrs = {
-          id: option_id(index),
-          class: "hakumi-segmented-input",
-          disabled: option_disabled?(option),
-          data: {
-            "hakumi--segmented-target": "input",
-            action: "change->hakumi--segmented#select"
-          }
-        }
-
-        aria_label = option_aria_label(option)
-        attrs[:"aria-label"] = aria_label if aria_label
-
-        attrs
-      end
-
-      def option_selected?(option)
-        return false if @value.nil?
-
-        option[:value].to_s == @value.to_s
-      end
-
-      def option_disabled?(option)
-        @disabled || option[:disabled]
-      end
-
-      def option_id(index)
-        "#{@name}_#{index}"
-      end
-
-      def option_label(option)
-        label = option[:label]
-        return nil if label.nil?
-        return label if label.is_a?(String)
-        return render(label) if label.respond_to?(:render_in)
-
-        label.to_s
-      end
-
-      def option_icon(option)
-        icon = option[:icon]
-        return nil if icon.nil?
-
-        if icon.is_a?(String) || icon.is_a?(Symbol)
-          render Hakumi::Icon::Component.new(name: icon, color: "currentColor")
-        elsif icon.respond_to?(:render_in)
-          render(icon)
-        else
-          icon
-        end
-      end
-
-      private
-
-      def validate_props!
-        validate_inclusion!(:size, SIZES)
-      end
-
-      def wrapper_classes
-        modifiers = {
-          block: @block,
-          vertical: @vertical,
-          round: @round,
-          disabled: @disabled
-        }
-
-        modifiers[@size] = true if @size != :middle
-
-        class_names("segmented", modifiers, [ @html_options[:class] ])
-      end
-
-      def normalize_options(options)
-        Array(options).map.with_index do |option, index|
-          if option.is_a?(Hash)
-            label_key_present = option.key?(:label) || option.key?("label")
-            value_key_present = option.key?(:value) || option.key?("value")
-            label_value = if label_key_present
-                            option[:label] || option["label"]
-            else
-                            option[:value] || option["value"] || "Option #{index + 1}"
-            end
-            value_value = if value_key_present
-                            option[:value] || option["value"]
-            else
-                            label_value
-            end
-
-            {
-              label: label_value,
-              value: value_value,
-              disabled: cast_boolean(option[:disabled] || option["disabled"]),
-              icon: option[:icon] || option["icon"],
-              class_name: option[:class_name] || option["class_name"],
-              aria_label: option[:aria_label] || option["aria_label"]
-            }
-          else
-            {
-              label: option,
-              value: option,
-              disabled: false,
-              icon: nil,
-              class_name: nil,
-              aria_label: nil
-            }
-          end
-        end
-      end
-
-      def option_aria_label(option)
-        return option[:aria_label] if option[:aria_label].present?
-
-        label = option[:label]
-        return strip_tags(label.to_s) if label.is_a?(String)
-        return option[:value].to_s if option[:value].present?
-
-        nil
-      end
-
-      def icon_only_option?(option)
-        icon = option[:icon]
-        label = option[:label]
-        icon.present? && (label.nil? || (label.respond_to?(:empty?) && label.empty?))
-      end
-
-      def data_attributes
-        {
-          controller: "hakumi--segmented",
-          "hakumi--segmented-disabled-value": @disabled,
-          "hakumi--segmented-value-value": @value
-        }.compact
-      end
-
-      def normalize_value(value, default_value)
-        raw = value.nil? ? default_value : value
-        raw.nil? ? nil : raw.to_s
-      end
-
-      def normalize_size(size)
-        val = size.is_a?(String) ? size.strip : size
-        symbol = val.presence&.to_sym
-        symbol == :default ? :middle : symbol
-      end
-
-      def normalize_string(value)
-        return nil if value.nil?
-
-        value = value.to_s.strip
-        value.presence
-      end
-
-      def self.parse_options_param(options)
-        return options if options.is_a?(Array)
-        return nil if options.nil?
-
-        if options.is_a?(String)
-          begin
-            parsed = JSON.parse(options)
-            return parsed
-          rescue JSON::ParserError
-            return options.split(",")
-          end
-        end
-
-        options
-      end
-
-      def self.truthy_param?(value)
-        return value if value == true || value == false
-
-        value.to_s == "true"
-      end
-    end
-  end
-end

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

@@ -1,125 +0,0 @@
-# frozen_string_literal: true
-
-module Hakumi
-  module Select
-    # Hakumi Select component
-    # A custom selector component that mimics Ant Design React behavior
-    class Component < Hakumi::BaseComponent
-      include Hakumi::Concerns::FormField
-
-      SIZES = [ :small, :middle, :large ].freeze
-      VARIANTS = [ :default, :borderless ].freeze
-      TRIGGERS = [ :click, :hover ].freeze
-
-      def initialize(
-        name: nil,
-        options: [],
-        label: nil,
-        caption: nil,
-        value: nil,
-        placeholder: nil,
-        size: :middle,
-        variant: :default,
-        trigger: :click,
-        icon: nil,
-        disabled: false,
-        required: false,
-        allow_clear: false,
-        show_search: false,
-        standalone: true,
-        errors: [],
-        **html_options
-      )
-        @name = name || generate_id("select")
-        @options = options
-        @label = label
-        @caption = caption
-        @value = value
-        @placeholder = placeholder
-        @size = size
-        @variant = variant
-        @trigger = trigger
-        @icon = icon
-        @disabled = disabled
-        @required = required
-        @allow_clear = allow_clear
-        @show_search = show_search
-        @standalone = standalone
-        @errors = Array(errors)
-        @html_options = html_options
-
-        validate_props!
-      end
-
-      attr_reader :variant, :trigger, :icon
-
-      private
-
-      def validate_props!
-        validate_inclusion!(:size, SIZES)
-        validate_inclusion!(:variant, VARIANTS)
-        validate_inclusion!(:trigger, TRIGGERS)
-      end
-
-      def select_wrapper_classes
-        class_names(
-          "select",
-          {
-            lg: @size == :large,
-            sm: @size == :small,
-            borderless: @variant == :borderless,
-            "hover-trigger": @trigger == :hover,
-            disabled: @disabled,
-            "show-search": @show_search,
-            "allow-clear": @allow_clear,
-            "has-value": @value.present?
-          },
-          [ @html_options[:class] ]
-        )
-      end
-
-      def borderless?
-        @variant == :borderless
-      end
-
-      def hover_trigger?
-        @trigger == :hover
-      end
-
-      def wrapper_attributes
-        base_attrs = {
-          class: select_wrapper_classes,
-          data: {
-            controller: "hakumi--select",
-            hakumi__select_allow_clear_value: @allow_clear ? "true" : "false",
-            hakumi__select_disabled_value: @disabled ? "true" : "false",
-            hakumi__select_trigger_value: @trigger.to_s
-          }
-        }
-
-        # Merge html_options but exclude :class since it's already in select_wrapper_classes
-        extra_options = @html_options.except(:class)
-        merge_attributes(base_attrs, extra_options)
-      end
-
-      # Returns the label for the currently selected value
-      def selected_label
-        return nil if @value.blank?
-
-        option = @options.find { |opt| opt[1].to_s == @value.to_s }
-        option ? option[0] : @value
-      end
-
-      # Ensures options are in [label, value] format
-      def formatted_options
-        @options.map do |opt|
-          if opt.is_a?(Array)
-            [ opt[0], opt[1] ]
-          else
-            [ opt, opt ]
-          end
-        end
-      end
-    end
-  end
-end

data/app/components/hakumi/skeleton/avatar/component.rb

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-
-module Hakumi
-  module Skeleton
-    module Avatar
-      class Component < Hakumi::BaseComponent
-        SIZES = [ :small, :default, :large ].freeze
-        SHAPES = [ :circle, :square ].freeze
-
-        def initialize(active: false, size: :default, shape: :circle, **html_options)
-          @active = active
-          @size = normalize_size(size)
-          @shape = normalize_shape(shape)
-          @html_options = html_options
-
-          validate_props!
-        end
-
-        def wrapper_attributes
-          merge_attributes({ class: wrapper_classes }, @html_options.except(:class))
-        end
-
-        def avatar_classes
-          modifiers = {}
-          modifiers[@size] = true if @size && !@size.is_a?(Numeric) && @size != :default
-          modifiers[@shape] = true if @shape
-
-          class_names("skeleton-avatar", modifiers)
-        end
-
-        def avatar_style
-          return nil unless @size.is_a?(Numeric)
-
-          "width: #{@size}px; height: #{@size}px;"
-        end
-
-        private
-
-        def normalize_size(size)
-          return size if size.is_a?(Numeric)
-
-          size.to_sym
-        end
-
-        def normalize_shape(shape)
-          shape.to_sym
-        end
-
-        def wrapper_classes
-          class_names("skeleton", { element: true, active: @active }, @html_options[:class])
-        end
-
-        def validate_props!
-          validate_inclusion_value(:size, @size, SIZES) if @size && !@size.is_a?(Numeric)
-          validate_inclusion_value(:shape, @shape, SHAPES) if @shape
-        end
-
-        def validate_inclusion_value(name, value, allowed)
-          return if allowed.include?(value)
-
-          raise ArgumentError, "#{name} must be one of #{allowed.inspect}, got #{value.inspect}"
-        end
-      end
-    end
-  end
-end

data/app/components/hakumi/skeleton/button/component.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-module Hakumi
-  module Skeleton
-    module Button
-      class Component < Hakumi::BaseComponent
-        SIZES = [ :small, :default, :large ].freeze
-        SHAPES = [ :default, :circle, :round ].freeze
-
-        def initialize(active: false, size: :default, shape: :default, block: false, **html_options)
-          @active = active
-          @size = normalize_size(size)
-          @shape = normalize_shape(shape)
-          @block = block
-          @html_options = html_options
-
-          validate_props!
-        end
-
-        def wrapper_attributes
-          merge_attributes({ class: wrapper_classes }, @html_options.except(:class))
-        end
-
-        def button_classes
-          modifiers = {}
-          modifiers[@size] = true if @size && @size != :default
-          modifiers[@shape] = true if @shape && @shape != :default
-
-          class_names("skeleton-button", modifiers)
-        end
-
-        private
-
-        def normalize_size(size)
-          size.to_sym
-        end
-
-        def normalize_shape(shape)
-          shape.to_sym
-        end
-
-        def wrapper_classes
-          class_names("skeleton", { element: true, active: @active, block: @block }, @html_options[:class])
-        end
-
-        def validate_props!
-          validate_inclusion_value(:size, @size, SIZES) if @size
-          validate_inclusion_value(:shape, @shape, SHAPES) if @shape
-        end
-
-        def validate_inclusion_value(name, value, allowed)
-          return if allowed.include?(value)
-
-          raise ArgumentError, "#{name} must be one of #{allowed.inspect}, got #{value.inspect}"
-        end
-      end
-    end
-  end
-end

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

@@ -1,200 +0,0 @@
-# frozen_string_literal: true
-
-module Hakumi
-  module Skeleton
-    class Component < Hakumi::BaseComponent
-      AVATAR_SIZES = [ :small, :default, :large ].freeze
-      AVATAR_SHAPES = [ :circle, :square ].freeze
-      DEFAULT_PARAGRAPH_ROWS = 3
-
-      def self.extract_controller_locals(params)
-        locals = {
-          loading: params.key?(:loading) ? ActiveModel::Type::Boolean.new.cast(params[:loading]) : true,
-          active: ActiveModel::Type::Boolean.new.cast(params[:active]),
-          round: ActiveModel::Type::Boolean.new.cast(params[:round])
-        }
-
-        locals[:avatar] = normalize_config_param(params[:avatar]) if params.key?(:avatar)
-        locals[:title] = normalize_config_param(params[:title]) if params.key?(:title)
-        locals[:paragraph] = normalize_config_param(params[:paragraph]) if params.key?(:paragraph)
-
-        locals
-      end
-
-      def initialize(
-        loading: true,
-        active: false,
-        avatar: false,
-        title: true,
-        paragraph: true,
-        round: false,
-        **html_options
-      )
-        @loading = loading
-        @active = active
-        @round = round
-        @avatar = normalize_config(avatar)
-        @title = normalize_config(title)
-        @paragraph = normalize_config(paragraph)
-        @html_options = html_options
-
-        validate_props!
-      end
-
-      def loading?
-        @loading
-      end
-
-      def wrapper_attributes
-        merge_attributes(
-          { class: wrapper_classes },
-          @html_options.except(:class)
-        )
-      end
-
-      def avatar?
-        !@avatar.nil?
-      end
-
-      def title?
-        !@title.nil?
-      end
-
-      def paragraph?
-        !@paragraph.nil?
-      end
-
-      def avatar_classes
-        modifiers = {}
-        modifiers[avatar_size] = true if avatar_size && avatar_size != :default
-        modifiers[avatar_shape] = true if avatar_shape
-
-        class_names("skeleton-avatar", modifiers)
-      end
-
-      def avatar_style
-        return nil unless avatar_size.is_a?(Numeric)
-
-        "width: #{avatar_size}px; height: #{avatar_size}px;"
-      end
-
-      def title_style
-        width = dimension_to_css(@title&.dig(:width))
-        return nil unless width
-
-        "width: #{width};"
-      end
-
-      def paragraph_row_widths
-        return [] unless paragraph?
-
-        rows = paragraph_rows
-        widths = @paragraph&.dig(:widths) || @paragraph&.dig(:width)
-
-        resolved = case widths
-        when Array
-          widths
-        when nil
-          default_paragraph_widths(rows)
-        else
-          Array.new(rows, widths)
-        end
-
-        resolved = resolved.first(rows)
-        resolved.fill("100%", resolved.length...rows)
-        resolved.map { |value| dimension_to_css(value) }
-      end
-
-      def paragraph_row_style(width)
-        return nil unless width
-
-        "width: #{width};"
-      end
-
-      def paragraph_rows
-        rows = @paragraph&.dig(:rows)
-        rows = rows.to_i if rows.is_a?(String)
-        rows.presence || DEFAULT_PARAGRAPH_ROWS
-      end
-
-      private
-
-      def self.normalize_config_param(value)
-        return nil if value.nil?
-
-        if value.is_a?(ActionController::Parameters)
-          value = value.to_unsafe_h
-        end
-
-        return value.symbolize_keys if value.is_a?(Hash)
-
-        ActiveModel::Type::Boolean.new.cast(value)
-      end
-
-      def normalize_config(value)
-        return nil if value.nil? || value == false
-        return {} if value == true
-
-        return value.to_h.symbolize_keys if value.respond_to?(:to_h)
-
-        {}
-      end
-
-      def wrapper_classes
-        modifiers = {
-          active: @active,
-          "with-avatar": avatar?,
-          "with-title": title?,
-          "with-paragraph": paragraph?,
-          round: @round
-        }
-
-        class_names("skeleton", modifiers, @html_options[:class])
-      end
-
-      def avatar_size
-        size = @avatar&.dig(:size)
-        size = size.to_sym if size.is_a?(String)
-        size.presence || :default
-      end
-
-      def avatar_shape
-        shape = @avatar&.dig(:shape)
-        shape = shape.to_sym if shape.is_a?(String)
-        shape.presence || :circle
-      end
-
-      def default_paragraph_widths(rows)
-        widths = Array.new(rows, "100%")
-        widths[-1] = "61%" if rows > 1
-        widths
-      end
-
-      def validate_props!
-        if avatar?
-          size = avatar_size
-          shape = avatar_shape
-
-          validate_inclusion_value(:avatar_size, size, AVATAR_SIZES) if size && !size.is_a?(Numeric)
-          validate_inclusion_value(:avatar_shape, shape, AVATAR_SHAPES) if shape
-        end
-
-        if paragraph?
-          rows = @paragraph[:rows]
-          rows = rows.to_i if rows.is_a?(String)
-          if rows && (!rows.is_a?(Integer) || rows < 1)
-            raise ArgumentError, "paragraph rows must be a positive integer"
-          end
-
-          @paragraph[:rows] = rows if rows
-        end
-      end
-
-      def validate_inclusion_value(name, value, allowed)
-        return if allowed.include?(value)
-
-        raise ArgumentError, "#{name} must be one of #{allowed.inspect}, got #{value.inspect}"
-      end
-    end
-  end
-end