hakumi_components 0.1.17.pre → 0.1.19.pre

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

@@ -1,339 +0,0 @@
-# frozen_string_literal: true
-
-module Hakumi
-  module QrCode
-    class Component < Hakumi::BaseComponent
-      TYPES = [ :canvas, :svg ].freeze
-      STATUSES = [ :active, :expired, :loading, :scanned ].freeze
-      ERROR_LEVELS = [ :L, :M, :Q, :H ].freeze
-
-      def self.extract_controller_locals(params)
-        {
-          value: params[:value],
-          size: parse_number(params[:size]),
-          type: params[:type]&.to_sym,
-          color: params[:color],
-          bg_color: params[:bg_color],
-          icon: params[:icon],
-          icon_size: parse_number(params[:icon_size]),
-          status: params[:status]&.to_sym,
-          status_render: params[:status_render],
-          bordered: params.key?(:bordered) ? ActiveModel::Type::Boolean.new.cast(params[:bordered]) : nil,
-          error_level: parse_error_level(params[:error_level]),
-          download_name: params[:download_name],
-          aria_label: params[:aria_label]
-        }
-      end
-
-      def self.parse_number(value)
-        return nil if value.nil?
-        return value if value.is_a?(Numeric)
-        raw = value.to_s.strip
-        return nil if raw.empty?
-
-        number = raw.to_f
-        number == number.to_i ? number.to_i : number
-      end
-
-      def self.parse_error_level(value)
-        return nil if value.nil?
-
-        value.to_s.strip.presence&.upcase&.to_sym
-      end
-
-      def initialize(
-        value:,
-        size: 160,
-        type: :canvas,
-        color: nil,
-        bg_color: nil,
-        icon: nil,
-        icon_size: 40,
-        status: :active,
-        status_render: nil,
-        bordered: true,
-        error_level: :M,
-        download_name: nil,
-        aria_label: nil,
-        **html_options
-      )
-        @value = value
-        @size = self.class.parse_number(size) || 160
-        @type = normalize_symbol(type) || :canvas
-        @color = normalize_string(color)
-        @bg_color = normalize_string(bg_color)
-        @icon_input = icon
-        @icon_size = self.class.parse_number(icon_size) || 40
-        resolve_icon!
-        @status = normalize_symbol(status) || :active
-        @status_render = status_render
-        @bordered = bordered.nil? ? true : ActiveModel::Type::Boolean.new.cast(bordered)
-        @error_level = normalize_error_level(error_level) || :M
-        @download_name = normalize_string(download_name)
-        @aria_label = normalize_string(aria_label)
-        @html_options = html_options
-
-        validate_props!
-      end
-
-      def wrapper_attributes
-        merge_attributes(
-          {
-            class: wrapper_classes,
-            style: wrapper_styles,
-            role: "img",
-            "aria-label": @aria_label || "QR Code",
-            "aria-busy": loading? ? "true" : "false",
-            data: data_attributes
-          },
-          @html_options
-        )
-      end
-
-      def renderer_attributes
-        {
-          class: "hakumi-qr-code-inner",
-          data: { "hakumi--qr-code-target": "renderer" }
-        }
-      end
-
-      def icon?
-        icon_component? || icon_image?
-      end
-
-      def icon_markup
-        if icon_image?
-          tag.img(**icon_image_attributes)
-        elsif icon_component?
-          render(@icon_component)
-        end
-      end
-
-      def icon_image_attributes
-        {
-          src: @icon_url,
-          alt: "",
-          class: "hakumi-qr-code-icon-image",
-          "aria-hidden": true,
-          role: "presentation"
-        }
-      end
-
-      def status_overlay?
-        @status != :active
-      end
-
-      def status_overlay_markup
-        return nil unless status_overlay?
-
-        custom = custom_status_overlay
-        return custom if custom
-
-        default_status_overlay
-      end
-
-      def status_text
-        case @status
-        when :expired
-          "Expired"
-        when :loading
-          "Loading"
-        when :scanned
-          "Scanned"
-        else
-          "Active"
-        end
-      end
-
-      def status_description
-        case @status
-        when :expired
-          "Please refresh to continue"
-        when :scanned
-          "You can now continue"
-        else
-          nil
-        end
-      end
-
-      private
-
-      def validate_props!
-        validate_required!(:value)
-        validate_inclusion!(:type, TYPES)
-        validate_inclusion!(:status, STATUSES)
-        validate_inclusion!(:error_level, ERROR_LEVELS)
-
-        if @size.nil? || @size.to_f <= 0
-          raise ArgumentError, "size must be a positive number"
-        end
-
-        if icon? && (@icon_size.nil? || @icon_size.to_f <= 0)
-          raise ArgumentError, "icon_size must be a positive number"
-        end
-      end
-
-      def wrapper_classes
-        modifiers = {
-          @type => true,
-          "status-#{@status}" => true,
-          bordered: @bordered,
-          "with-icon" => icon?,
-          "custom-status" => custom_status_render?
-        }
-
-        class_names("qr-code", modifiers, [ @html_options[:class] ])
-      end
-
-      def wrapper_styles
-        styles = {
-          "--hakumi-qr-code-size" => size_css_value,
-          "--hakumi-qr-code-icon-size" => icon_css_value,
-          "--hakumi-qr-code-color" => @color,
-          "--hakumi-qr-code-bg-color" => @bg_color
-        }
-
-        styles.compact.map { |key, value| "#{key}: #{value}" }.join("; ")
-      end
-
-      def size_css_value
-        return nil unless @size
-
-        value = @size.to_f
-        value = value.to_i if value == value.to_i
-        "#{value}px"
-      end
-
-      def icon_css_value
-        return nil unless icon?
-
-        value = @icon_size.to_f
-        value = value.to_i if value == value.to_i
-        "#{value}px"
-      end
-
-      def resolve_icon!
-        @icon_component = nil
-        @icon_url = nil
-
-        if @icon_input.respond_to?(:render_in)
-          @icon_component = @icon_input
-          return
-        end
-
-        if @icon_input.is_a?(String)
-          trimmed = @icon_input.strip
-          if trimmed.downcase.start_with?("http://", "https://", "data:")
-            @icon_url = trimmed
-            return
-          end
-        end
-
-        icon_name = extract_icon_name(@icon_input)
-        return unless icon_name
-
-        @icon_component = Hakumi::Icon::Component.new(name: icon_name, size: icon_component_size)
-      end
-
-      def icon_component?
-        @icon_component.present?
-      end
-
-      def icon_image?
-        @icon_url.present?
-      end
-
-      def data_attributes
-        data = {
-          controller: "hakumi--qr-code",
-          "hakumi--qr-code-value-value": @value,
-          "hakumi--qr-code-size-value": @size,
-          "hakumi--qr-code-type-value": @type,
-          "hakumi--qr-code-color-value": @color,
-          "hakumi--qr-code-bg-color-value": @bg_color,
-          "hakumi--qr-code-error-level-value": @error_level,
-          "hakumi--qr-code-status-value": @status
-        }
-
-        data["hakumi--qr-code-download-name-value"] = @download_name if @download_name.present?
-        data
-      end
-
-      def loading?
-        @status == :loading
-      end
-
-      def custom_status_render?
-        @status_render.present?
-      end
-
-      def custom_status_overlay
-        return unless custom_status_render?
-
-        if @status_render.respond_to?(:call)
-          return view_context.capture { @status_render.call(@status) }
-        end
-
-        return render(@status_render) if @status_render.respond_to?(:render_in)
-
-        @status_render
-      end
-
-      def default_status_overlay
-        content = []
-        if loading?
-          content << render(Hakumi::Spin::Component.new(size: :small))
-        end
-
-        content << tag.span(status_text, class: "hakumi-qr-code-status-text")
-        if status_description.present?
-          content << tag.span(status_description, class: "hakumi-qr-code-status-description")
-        end
-
-        tag.div(class: "hakumi-qr-code-status-content") do
-          safe_join(content)
-        end
-      end
-
-      def normalize_symbol(value)
-        return nil if value.nil?
-
-        raw = value.is_a?(String) ? value.dup : value.to_s.dup
-        raw.strip!
-        return nil if raw.empty?
-
-        raw.to_sym
-      end
-
-      def normalize_error_level(value)
-        symbol = normalize_symbol(value)
-        symbol&.to_s&.upcase&.to_sym
-      end
-
-      def normalize_string(value)
-        return nil if value.nil?
-
-        raw = value.to_s.strip
-        raw.empty? ? nil : raw
-      end
-
-      def extract_icon_name(value)
-        case value
-        when Symbol
-          value
-        when String
-          trimmed = value.strip
-          return nil if trimmed.empty?
-          trimmed.to_sym
-        else
-          nil
-        end
-      end
-
-      def icon_component_size
-        size = (@icon_size.to_f * 0.65).round
-        size.positive? ? size : 24
-      end
-    end
-  end
-end

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

@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-
-module Hakumi
-  module Radio
-    class Component < Hakumi::BaseComponent
-      include Hakumi::Concerns::FormField
-
-      SIZES = [ :small, :middle, :large ].freeze
-
-      def initialize(
-        name:,
-        value: nil,
-        text: nil,
-        label: nil,
-        caption: nil,
-        checked: false,
-        disabled: false,
-        size: :middle,
-        id: nil,
-        auto_focus: false,
-        required: false,
-        standalone: true,
-        errors: [],
-        **html_options
-      )
-        @name = name
-        @value = value
-        @text = text
-        @label = label
-        @caption = caption
-        @checked = checked
-        @disabled = disabled
-        @size = size
-        @id = id || generate_id("radio")
-        @auto_focus = auto_focus
-        @required = required
-        @standalone = standalone
-        @errors = Array(errors)
-        @html_options = html_options
-        @html_options[:id] ||= @id
-
-        validate_props!
-      end
-
-      def wrapper_classes
-        modifiers = {
-          checked: @checked,
-          disabled: @disabled
-        }
-        modifiers[@size] = true if @size != :middle
-
-        class_names("radio-wrapper", modifiers)
-      end
-
-      def radio_classes
-        modifiers = {
-          checked: @checked,
-          disabled: @disabled
-        }
-        modifiers[@size] = true if @size != :middle
-
-        class_names("radio", modifiers)
-      end
-
-      def data_controllers
-        "hakumi--radio"
-      end
-
-      def label_text
-        @text || content
-      end
-
-      private
-
-      def validate_props!
-        validate_inclusion!(:size, SIZES)
-      end
-    end
-  end
-end

data/app/components/hakumi/radio/group/component.rb

@@ -1,132 +0,0 @@
-# frozen_string_literal: true
-
-module Hakumi
-  module Radio
-    module Group
-      class Component < Hakumi::BaseComponent
-        include Hakumi::Concerns::FormField
-
-        SIZES = [ :small, :middle, :large ].freeze
-        VARIANTS = [ :default, :button, :solid ].freeze
-        DIRECTIONS = [ :horizontal, :vertical ].freeze
-
-        def initialize(
-          name: nil,
-          value: nil,
-          options: [],
-          label: nil,
-          caption: nil,
-          variant: :default,
-          direction: :horizontal,
-          size: :middle,
-          disabled: false,
-          standalone: true,
-          required: false,
-          errors: [],
-          **html_options
-        )
-          @name = name || generate_id("radio_group")
-          @value = value
-          @options = normalize_options(options)
-          @label = label
-          @caption = caption
-          @variant = variant.to_sym
-          @direction = direction.to_sym
-          @size = size
-          @disabled = disabled
-          @standalone = standalone
-          @required = required
-          @errors = Array(errors)
-          @html_options = html_options
-
-          validate_props!
-        end
-
-        def wrapper_attributes
-          attrs = {
-            class: wrapper_classes,
-            role: "radiogroup",
-            "aria-orientation": (@direction == :vertical ? "vertical" : nil)
-          }.compact
-
-          merge_attributes(attrs, @html_options)
-        end
-
-        def normalized_options
-          @options
-        end
-
-        def option_checked?(option_value)
-          return false if @value.nil?
-
-          @value.to_s == option_value.to_s
-        end
-
-        def option_disabled?(option)
-          @disabled || option[:disabled]
-        end
-
-        def button_wrapper_classes(option)
-          modifiers = {
-            checked: option_checked?(option[:value]),
-            disabled: option_disabled?(option)
-          }
-          modifiers[@size] = true if @size != :middle
-
-          class_names("radio-button-wrapper", modifiers)
-        end
-
-        def option_id(index)
-          "#{@name}_#{index}"
-        end
-
-        def button_group?
-          @variant == :button || @variant == :solid
-        end
-
-        private
-
-        def wrapper_classes
-          modifiers = {
-            button: button_group?,
-            vertical: @direction == :vertical,
-            disabled: @disabled
-          }
-          modifiers[@size] = true if @size != :middle
-          modifiers[:solid] = true if @variant == :solid
-          modifiers[:outline] = true if @variant == :button
-
-          class_names("radio-group", modifiers)
-        end
-
-        def normalize_options(options)
-          Array(options).map do |option|
-            if option.is_a?(Hash)
-              option = option.deep_symbolize_keys if option.respond_to?(:deep_symbolize_keys)
-              label_value = option[:label]
-              value_value = option[:value] || label_value
-
-              raise ArgumentError, "Option must have :label key" if label_value.nil?
-
-              {
-                label: label_value,
-                value: value_value,
-                disabled: !!option[:disabled]
-              }
-            elsif option.is_a?(String)
-              { label: option, value: option, disabled: false }
-            else
-              raise ArgumentError, "Option must be a Hash with :label and :value, or a String. Got: #{option.class}"
-            end
-          end
-        end
-
-        def validate_props!
-          validate_inclusion!(:size, SIZES)
-          validate_inclusion!(:variant, VARIANTS)
-          validate_inclusion!(:direction, DIRECTIONS)
-        end
-      end
-    end
-  end
-end

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

@@ -1,125 +0,0 @@
-# frozen_string_literal: true
-
-module Hakumi
-  module Result
-    class Component < Hakumi::BaseComponent
-      STATUSES = %w[success info warning error].freeze
-
-      DEFAULT_TITLES = {
-        "success" => "Success",
-        "info" => "Information",
-        "warning" => "Warning",
-        "error" => "Error"
-      }.freeze
-
-      DEFAULT_ICON_NAME = "result_success"
-      STATUS_ICON_MAP = {
-        "success" => { name: "check-circle", theme: :filled, color: "var(--color-success)" },
-        "info" => { name: "info-circle", theme: :filled, color: "var(--color-primary)" },
-        "warning" => { name: "exclamation-circle", theme: :filled, color: "var(--color-warning)" },
-        "error" => { name: "close-circle", theme: :filled, color: "var(--color-error)" }
-      }.freeze
-      STATUS_ICON_SIZE = 72
-
-      def self.extract_controller_locals(params)
-        {
-          status: params[:status],
-          title: params[:title],
-          sub_title: params[:sub_title],
-          extra: params[:extra]
-        }
-      end
-
-      def initialize(status: :info, title: nil, sub_title: nil, icon: nil, extra: nil, **html_options)
-        @status = (status || :info).to_s
-        @title = title || DEFAULT_TITLES[@status]
-        @sub_title = sub_title
-        @icon = icon
-        @extra = extra
-        @html_options = html_options
-
-        validate_props!
-      end
-
-      def wrapper_attributes
-        merge_attributes(
-          {
-            class: wrapper_classes,
-            role: "status",
-            "aria-live": "polite"
-          },
-          @html_options.except(:class)
-        )
-      end
-
-      def icon_present?
-        @icon != false
-      end
-
-      def icon_content
-        return nil unless icon_present?
-
-        render_value(@icon || status_icon_component || default_icon)
-      end
-
-      def title_content
-        render_value(@title)
-      end
-
-      def sub_title_content
-        render_value(@sub_title)
-      end
-
-      def extra_content
-        render_value(@extra)
-      end
-
-      def content_present?
-        content.present?
-      end
-
-      def extra_present?
-        @extra.present?
-      end
-
-      def title_present?
-        @title.present?
-      end
-
-      def sub_title_present?
-        @sub_title.present?
-      end
-
-      private
-
-      def validate_props!
-        validate_inclusion!(:status, STATUSES)
-      end
-
-      def wrapper_classes
-        class_names(
-          "result",
-          { @status => true },
-          [ @html_options[:class] ]
-        )
-      end
-
-
-      def status_icon_component
-        config = STATUS_ICON_MAP[@status]
-        return unless config
-
-        Hakumi::Icon::Component.new(
-          name: config[:name],
-          theme: config[:theme],
-          size: STATUS_ICON_SIZE,
-          color: config[:color]
-        )
-      end
-
-      def default_icon
-        Hakumi::Illustrations::Loader.load(DEFAULT_ICON_NAME)
-      end
-    end
-  end
-end