hakumi_components 0.1.17.pre → 0.1.19.pre

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

@@ -0,0 +1,175 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Result
+    class Component < HakumiComponents::BaseComponent
+      extend T::Sig
+
+      Status = T.type_alias { T.any(Symbol, String) }
+      IconOverride = T.type_alias { T.any(FalseClass, HakumiComponents::Types::Renderable) }
+      STATUSES = T.let(%i[success info warning error].freeze, T::Array[Symbol])
+
+      DEFAULT_TITLES = T.let({
+        success: "Success",
+        info: "Information",
+        warning: "Warning",
+        error: "Error"
+      }.freeze, T::Hash[Symbol, String])
+
+      DEFAULT_ICON_NAME = T.let("result_success", String)
+      STATUS_ICON_MAP = T.let({
+        success: [ "check-circle", :filled, "var(--color-success)" ],
+        info: [ "info-circle", :filled, "var(--color-primary)" ],
+        warning: [ "exclamation-circle", :filled, "var(--color-warning)" ],
+        error: [ "close-circle", :filled, "var(--color-error)" ]
+      }.freeze, T::Hash[Symbol, [ String, Symbol, String ]])
+      STATUS_ICON_SIZE = T.let(72, Integer)
+
+      renders_one :title
+      renders_one :sub_title
+      renders_one :extra
+
+      sig do
+        params(
+          params: T.any(ActionController::Parameters, HakumiComponents::Types::HtmlAttributes)
+        ).returns(HakumiComponents::Types::HtmlAttributes)
+      end
+      def self.extract_controller_locals(params)
+        {
+          status: symbol_html_param(html_param(params, :status)),
+          title: html_primitive_param(html_param(params, :title)),
+          sub_title: html_primitive_param(html_param(params, :sub_title)),
+          icon: icon_html_param(html_param(params, :icon)),
+          extra: html_primitive_param(html_param(params, :extra))
+        }
+      end
+
+      sig { params(value: HakumiComponents::Types::HtmlAttributeValue).returns(T.nilable(FalseClass)) }
+      def self.icon_html_param(value)
+        boolean_html_param(value) == false ? false : nil
+      end
+
+      sig do
+        params(
+          status: Status,
+          title: HakumiComponents::Types::Renderable,
+          sub_title: HakumiComponents::Types::Renderable,
+          icon: T.nilable(IconOverride),
+          extra: HakumiComponents::Types::Renderable,
+          html_options: HakumiComponents::Types::HtmlAttributeValue
+        ).void
+      end
+      def initialize(status: :info, title: nil, sub_title: nil, icon: nil, extra: nil, **html_options)
+        @status = T.let(status.to_sym, Symbol)
+        @title = T.let(title || DEFAULT_TITLES[@status], HakumiComponents::Types::Renderable)
+        @sub_title = T.let(sub_title, HakumiComponents::Types::Renderable)
+        @icon = T.let(icon, T.nilable(IconOverride))
+        @extra = T.let(extra, HakumiComponents::Types::Renderable)
+        @html_options = T.let(html_options, HakumiComponents::Types::HtmlAttributes)
+
+        validate_props!
+      end
+
+      sig { returns(HakumiComponents::Types::HtmlAttributes) }
+      def wrapper_attributes
+        merge_attributes(
+          {
+            class: wrapper_classes,
+            role: "status",
+            "aria-live": "polite"
+          },
+          @html_options.except(:class)
+        )
+      end
+
+      sig { returns(T::Boolean) }
+      def icon_present?
+        @icon != false
+      end
+
+      sig { returns(HakumiComponents::Types::Renderable) }
+      def icon_content
+        return nil unless icon_present?
+
+        render_value(@icon || status_icon_component || default_icon)
+      end
+
+      sig { returns(HakumiComponents::Types::Renderable) }
+      def title_content
+        return render_value(title) if title?
+
+        render_value(@title)
+      end
+
+      sig { returns(HakumiComponents::Types::Renderable) }
+      def sub_title_content
+        return render_value(sub_title) if sub_title?
+
+        render_value(@sub_title)
+      end
+
+      sig { returns(HakumiComponents::Types::Renderable) }
+      def extra_content
+        return render_value(extra) if extra?
+
+        render_value(@extra)
+      end
+
+      sig { returns(T::Boolean) }
+      def content_present?
+        content.present?
+      end
+
+      sig { returns(T::Boolean) }
+      def extra_present?
+        extra? || @extra.present?
+      end
+
+      sig { returns(T::Boolean) }
+      def title_present?
+        title? || @title.present?
+      end
+
+      sig { returns(T::Boolean) }
+      def sub_title_present?
+        sub_title? || @sub_title.present?
+      end
+
+      private
+
+      sig { void }
+      def validate_props!
+        validate_inclusion!(:status, STATUSES)
+      end
+
+      sig { returns(String) }
+      def wrapper_classes
+        component_classes(
+          "result",
+          { @status => true },
+          @html_options
+        )
+      end
+
+      sig { returns(T.nilable(HakumiComponents::Icon::Component)) }
+      def status_icon_component
+        config = STATUS_ICON_MAP[@status]
+        return unless config
+
+        name, theme, color = config
+        HakumiComponents::Icon::Component.new(
+          name: name,
+          theme: theme,
+          size: STATUS_ICON_SIZE,
+          color: color
+        )
+      end
+
+      sig { returns(HakumiComponents::Types::Renderable) }
+      def default_icon
+        HakumiComponents::Illustrations::Loader.load(DEFAULT_ICON_NAME)
+      end
+    end
+  end
+end

data/app/components/{hakumi → hakumi_components}/segmented/component.html.erb

@@ -4,7 +4,7 @@
     <%= tag.label(class: option_classes(option), data: option_data_attributes(option)) do %>
       <%= radio_button_tag(
             @name,
-            option[:value],
+            option.value,
             option_selected?(option),
             **option_input_attributes(option, index)
           ) %>

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

@@ -0,0 +1,232 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Segmented
+    class Component < HakumiComponents::BaseComponent
+      extend T::Sig
+
+      sig do
+        params(
+          params: T.any(ActionController::Parameters, Types::HtmlAttributes)
+        ).returns(Types::HtmlAttributes)
+      end
+      def self.extract_controller_locals(params)
+        options = html_param(params, :options)
+        options = html_param(params, :options_json) if options.nil?
+
+        normalized_options = if options.is_a?(String) || options.is_a?(Array)
+          HakumiComponents::Segmented::Option.coerce_all(options)
+        else
+          nil
+        end
+
+        {
+          options: normalized_options,
+          value: html_param(params, :value),
+          default_value: html_param(params, :default_value),
+          disabled: boolean_html_param(html_param(params, :disabled)),
+          block: boolean_html_param(html_param(params, :block)),
+          vertical: boolean_html_param(html_param(params, :vertical)),
+          round: boolean_html_param(html_param(params, :round)),
+          name: string_html_param(html_param(params, :name)),
+          size: symbol_html_param(html_param(params, :size)),
+          aria_label: string_html_param(html_param(params, :aria_label))
+        }.compact
+      end
+
+      sig do
+        params(
+          options: T.any(String, T::Array[T.any(Types::FormFieldScalar, Types::HtmlAttributes)]),
+          value: Types::FormFieldScalar,
+          default_value: Types::FormFieldScalar,
+          disabled: T::Boolean,
+          block: T::Boolean,
+          vertical: T::Boolean,
+          round: T::Boolean,
+          name: T.nilable(String),
+          size: Symbol,
+          aria_label: T.nilable(String),
+          html_options: Types::HtmlAttributeValue
+        ).void
+      end
+      def initialize(
+        options: [],
+        value: nil,
+        default_value: nil,
+        disabled: false,
+        block: false,
+        vertical: false,
+        round: false,
+        name: nil,
+        size: :default,
+        aria_label: nil,
+        **html_options
+      )
+        @options = T.let(HakumiComponents::Segmented::Option.coerce_all(options), T::Array[HakumiComponents::Segmented::Option])
+        @value = T.let(normalize_value(value, default_value), T.nilable(String))
+        @value = T.let(@options.first&.string_value, T.nilable(String)) if @value.nil? && @options.any?
+        @disabled = T.let(disabled, T::Boolean)
+        @block = T.let(block, T::Boolean)
+        @vertical = T.let(vertical, T::Boolean)
+        @round = T.let(round, T::Boolean)
+        @name = T.let(name.presence || generate_id("segmented"), String)
+        @size = T.let(size, Symbol)
+        @aria_label = T.let(aria_label, T.nilable(String))
+        @html_options = T.let(html_options, Types::HtmlAttributes)
+
+        validate_props!
+      end
+
+      sig { returns(Types::HtmlAttributes) }
+      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
+
+      sig { returns(T::Array[HakumiComponents::Segmented::Option]) }
+      def normalized_options
+        @options
+      end
+
+      sig { params(option: HakumiComponents::Segmented::Option).returns(String) }
+      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 option.icon_only?)
+          ]
+        )
+      end
+
+      sig { params(option: HakumiComponents::Segmented::Option).returns(Types::DataAttributes) }
+      def option_data_attributes(option)
+        {
+          "hakumi--segmented-target": "item",
+          value: option.string_value,
+          label: option.label.is_a?(String) ? option.label : nil,
+          disabled: option_disabled?(option) ? "true" : nil
+        }.compact
+      end
+
+      sig { params(option: HakumiComponents::Segmented::Option, index: Integer).returns(Types::HtmlAttributes) }
+      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
+
+      sig { params(option: HakumiComponents::Segmented::Option).returns(T::Boolean) }
+      def option_selected?(option)
+        return false if @value.nil?
+
+        option.string_value == @value.to_s
+      end
+
+      sig { params(option: HakumiComponents::Segmented::Option).returns(T::Boolean) }
+      def option_disabled?(option)
+        @disabled || option.disabled
+      end
+
+      sig { params(index: Integer).returns(String) }
+      def option_id(index)
+        "#{@name}_#{index}"
+      end
+
+      sig { params(option: HakumiComponents::Segmented::Option).returns(T.nilable(String)) }
+      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
+
+      sig { params(option: HakumiComponents::Segmented::Option).returns(T.nilable(Types::RenderedContent)) }
+      def option_icon(option)
+        icon = option.icon
+        return nil if icon.nil?
+
+        if icon.is_a?(String) || icon.is_a?(Symbol)
+          render HakumiComponents::Icon::Component.new(name: icon, color: "currentColor")
+        elsif icon.respond_to?(:render_in)
+          render(icon)
+        else
+          nil
+        end
+      end
+
+      private
+
+      sig { void }
+      def validate_props!
+        validate_inclusion!(:size, SIZES)
+      end
+
+      sig { returns(String) }
+      def wrapper_classes
+        modifiers = {
+          block: @block,
+          vertical: @vertical,
+          round: @round,
+          disabled: @disabled
+        }
+
+        modifiers[@size] = true if @size != :default
+
+        class_names("segmented", modifiers, html_classes(@html_options))
+      end
+
+      sig { params(option: HakumiComponents::Segmented::Option).returns(T.nilable(String)) }
+      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.string_value if option.value.present?
+
+        nil
+      end
+
+      sig { returns(Types::DataAttributes) }
+      def data_attributes
+        {
+          controller: "hakumi--segmented",
+          "hakumi--segmented-disabled-value": @disabled,
+          "hakumi--segmented-value-value": @value
+        }.compact
+      end
+
+      sig { params(value: Types::FormFieldScalar, default_value: Types::FormFieldScalar).returns(T.nilable(String)) }
+      def normalize_value(value, default_value)
+        raw = value.nil? ? default_value : value
+        raw.nil? ? nil : raw.to_s
+      end
+    end
+  end
+end

data/app/components/hakumi_components/segmented/option.rb

@@ -0,0 +1,191 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Segmented
+    class Option
+      extend T::Sig
+
+      IconValue = T.type_alias { T.nilable(T.any(String, Symbol, ViewComponent::Base, ViewComponent::Slot)) }
+      JsonValue = T.type_alias { T.nilable(T.any(String, Numeric, T::Boolean, T::Array[T.untyped], T::Hash[String, T.untyped])) }
+      ParsedEntry = T.type_alias { T.any(HakumiComponents::Segmented::Option, HakumiComponents::Types::FormFieldScalar, Types::HtmlAttributes) }
+
+      sig do
+        params(
+          label: T.nilable(Types::Renderable),
+          value: Types::FormFieldScalar,
+          disabled: T::Boolean,
+          icon: IconValue,
+          class_name: T.nilable(String),
+          aria_label: T.nilable(String)
+        ).void
+      end
+      def initialize(label:, value:, disabled: false, icon: nil, class_name: nil, aria_label: nil)
+        @label = T.let(label, T.nilable(Types::Renderable))
+        @value = T.let(value, Types::FormFieldScalar)
+        @disabled = T.let(disabled, T::Boolean)
+        @icon = T.let(icon, IconValue)
+        @class_name = T.let(class_name, T.nilable(String))
+        @aria_label = T.let(aria_label, T.nilable(String))
+      end
+
+      sig { returns(T.nilable(Types::Renderable)) }
+      attr_reader :label
+
+      sig { returns(Types::FormFieldScalar) }
+      attr_reader :value
+
+      sig { returns(T::Boolean) }
+      attr_reader :disabled
+
+      sig { returns(IconValue) }
+      attr_reader :icon
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :class_name, :aria_label
+
+      sig { returns(String) }
+      def string_value
+        @value.to_s
+      end
+
+      sig { returns(T::Boolean) }
+      def icon_only?
+        @icon.present? && (@label.nil? || (@label.is_a?(String) && @label.empty?))
+      end
+
+      sig { params(options: T.any(String, T::Array[ParsedEntry], T.nilable(T::Array[ParsedEntry]))).returns(T::Array[HakumiComponents::Segmented::Option]) }
+      def self.coerce_all(options)
+        source = parse_options(options)
+        coerced = T.let([], T::Array[HakumiComponents::Segmented::Option])
+        Array(source).each_with_index do |option, index|
+          coerced << coerce(option, index)
+        end
+        coerced
+      end
+
+      sig { params(option: ParsedEntry, index: Integer).returns(HakumiComponents::Segmented::Option) }
+      def self.coerce(option, index)
+        return option if option.is_a?(HakumiComponents::Segmented::Option)
+
+        if option.is_a?(Hash)
+          label_value = extract_label(option, index)
+          value_value = extract_value(option, label_value)
+
+          return new(
+            label: label_value,
+            value: value_value,
+            disabled: HakumiComponents::BaseComponent.boolean_html_param(option[:disabled]) == true,
+            icon: coerce_icon(option[:icon]),
+            class_name: coerce_string(option[:class_name]),
+            aria_label: coerce_string(option[:aria_label])
+          )
+        end
+
+        new(label: option&.to_s, value: option, disabled: false)
+      end
+
+      class << self
+        extend T::Sig
+
+        private
+
+        sig { params(options: T.any(String, T::Array[ParsedEntry], T.nilable(T::Array[ParsedEntry]))).returns(T.nilable(T::Array[ParsedEntry])) }
+        def parse_options(options)
+          return options if options.is_a?(Array)
+          return nil if options.nil?
+
+          if options.is_a?(String)
+            begin
+              parsed = JSON.parse(options)
+              return parse_json_array(parsed) if parsed.is_a?(Array)
+            rescue JSON::ParserError
+              return options.split(",")
+            end
+          end
+
+          nil
+        end
+
+        sig { params(parsed: T::Array[JsonValue]).returns(T::Array[ParsedEntry]) }
+        def parse_json_array(parsed)
+          entries = T.let([], T::Array[ParsedEntry])
+          parsed.each do |entry|
+            if entry.is_a?(Hash)
+              attrs = T.let({}, Types::HtmlAttributes)
+              entry.each do |key, value|
+                next unless key.is_a?(String)
+
+                symbol_key = key.to_sym
+                attrs[symbol_key] = coerce_html_value(value)
+              end
+              entries << attrs
+            elsif entry.is_a?(String) || entry.is_a?(Numeric) || entry == true || entry == false
+              entries << entry
+            end
+          end
+          entries
+        end
+
+        sig { params(option: Types::HtmlAttributes, index: Integer).returns(T.nilable(Types::Renderable)) }
+        def extract_label(option, index)
+          if option.key?(:label)
+            coerce_label(option[:label])
+          else
+            coerce_label(option[:value] || "Option #{index + 1}")
+          end
+        end
+
+        sig { params(option: Types::HtmlAttributes, label_value: T.nilable(Types::Renderable)).returns(Types::FormFieldScalar) }
+        def extract_value(option, label_value)
+          if option.key?(:value)
+            raw = option[:value]
+            return raw if raw.nil? || raw.is_a?(String) || raw.is_a?(Symbol) || raw.is_a?(TrueClass) || raw.is_a?(FalseClass) || raw.is_a?(Numeric) || raw.is_a?(Date) || raw.is_a?(Time) || raw.is_a?(DateTime) || raw.is_a?(ActiveSupport::TimeWithZone)
+
+            raise ArgumentError, "segmented option value must be scalar"
+          end
+
+          return label_value if label_value.nil? || label_value.is_a?(String)
+
+          raise ArgumentError, "segmented option value must be scalar"
+        end
+
+        sig { params(value: Types::HtmlAttributeValue).returns(T.nilable(String)) }
+        def coerce_label(value)
+          return value if value.is_a?(String)
+          return nil if value.nil?
+          return value.to_s if scalar_value?(value)
+
+          nil
+        end
+
+        sig { params(value: Types::HtmlAttributeValue).returns(IconValue) }
+        def coerce_icon(value)
+          return value if value.is_a?(String)
+          return value if value.is_a?(Symbol)
+
+          nil
+        end
+
+        sig { params(value: Types::HtmlAttributeValue).returns(T.nilable(String)) }
+        def coerce_string(value)
+          return value if value.is_a?(String)
+
+          nil
+        end
+
+        sig { params(value: JsonValue).returns(Types::HtmlAttributeValue) }
+        def coerce_html_value(value)
+          return value if value.is_a?(String) || value.is_a?(Symbol) || value.is_a?(Numeric) || value == true || value == false
+
+          nil
+        end
+
+        sig { params(value: Types::HtmlAttributeValue).returns(T::Boolean) }
+        def scalar_value?(value)
+          value.nil? || value.is_a?(String) || value.is_a?(Symbol) || value.is_a?(TrueClass) || value.is_a?(FalseClass) || value.is_a?(Numeric)
+        end
+      end
+    end
+  end
+end