hakumi_components 0.1.17.pre → 0.1.19.pre

data/app/components/hakumi_components/base_component.rb

@@ -0,0 +1,391 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  class BaseComponent < ViewComponent::Base
+    extend T::Sig
+
+    SizeValue = T.type_alias { T.any(Types::HtmlKey, Integer) }
+    DimensionInput = T.type_alias { T.nilable(T.any(Numeric, String)) }
+    I18nOptionValue = T.type_alias { Types::ValidationComparable }
+    DateLikeValue = T.type_alias { T.any(Date, Time, DateTime, ActiveSupport::TimeWithZone) }
+    DateInput = T.type_alias { T.nilable(T.any(DateLikeValue, Types::HtmlKey)) }
+    SymbolInput = T.type_alias { T.nilable(Types::HtmlKey) }
+    PresenceArray = T.type_alias { T::Array[HakumiComponents::Types::FormFieldScalar] }
+    ControllerOptions = T.type_alias { T.any(ActionController::Parameters, Types::HtmlAttributes) }
+    PresenceScalar = T.type_alias { T.any(Types::ValidationPrimitive, DateLikeValue) }
+    HtmlPayloadInput = T.type_alias { T.any(ActionController::Parameters, Types::DataAttributes, Types::HtmlClassList) }
+    PresenceValue = T.type_alias do
+      T.nilable(T.any(
+        Types::Renderable,
+        PresenceScalar,
+        PresenceArray
+      ))
+    end
+    RawHtmlInput = T.type_alias do
+      T.nilable(T.any(
+        Types::HtmlPrimitive,
+        HtmlPayloadInput
+      ))
+    end
+
+    SIZES = T.let(%i[small default large].freeze, T::Array[Symbol])
+
+    sig { params(base: String, modifiers: Types::ClassModifiers, extras: Types::CssClasses).returns(String) }
+    def class_names(base, modifiers = {}, extras = [])
+      classes = [ "hakumi-#{base}" ]
+
+      modifiers.each do |key, value|
+        next if value.nil? || value == false
+
+        if value == true
+          classes << "hakumi-#{base}-#{key}"
+        else
+          classes << "hakumi-#{base}-#{key}-#{value}"
+        end
+      end
+
+      classes.concat(Array(extras).compact)
+      classes.join(" ")
+    end
+
+    sig { params(defaults: Types::HtmlAttributes, overrides: Types::HtmlAttributes).returns(Types::HtmlAttributes) }
+    def merge_attributes(defaults = {}, overrides = {})
+      merged = T.let(defaults.deep_dup, Types::HtmlAttributes)
+
+      if defaults[:class] && overrides[:class]
+        merged[:class] = [ defaults[:class], overrides[:class] ].join(" ")
+      elsif overrides[:class]
+        merged[:class] = overrides[:class]
+      end
+
+      if defaults[:style] && overrides[:style]
+        merged[:style] = [ defaults[:style].to_s.chomp(";"), overrides[:style] ].join("; ")
+      elsif overrides[:style]
+        merged[:style] = overrides[:style]
+      end
+
+      merged_data = merge_attribute_hash(defaults[:data], overrides[:data])
+      merged[:data] = merged_data if merged_data
+
+      merged_aria = merge_attribute_hash(defaults[:aria], overrides[:aria])
+      merged[:aria] = merged_aria if merged_aria
+
+      merged.merge!(overrides.except(:aria, :class, :data, :style))
+
+      ensure_dom_id!(merged)
+
+      merged
+    end
+
+    sig { params(value: PresenceValue).returns(T::Boolean) }
+    def value_present?(value)
+      return false if value.nil? || value == false
+      return !value.empty? if value.is_a?(String)
+      return !value.empty? if value.is_a?(Array)
+
+      true
+    end
+
+    sig { params(props: Symbol).void }
+    def validate_required!(*props)
+      props.each do |prop|
+        value = instance_variable_get("@#{prop}")
+        raise ArgumentError, "#{prop} is required" unless value_present?(value)
+      end
+    end
+
+    sig { params(prop: Symbol, allowed: T::Array[T.nilable(SizeValue)]).void }
+    def validate_inclusion!(prop, allowed)
+      value = instance_variable_get("@#{prop}")
+      return if value.nil?
+      return if allowed.include?(value)
+
+      raise ArgumentError, "#{prop} must be one of #{allowed.inspect}, got #{value.inspect}"
+    end
+
+    sig { params(attrs: Types::HtmlAttributes).void }
+    def ensure_dom_id!(attrs)
+      data = attrs[:data]
+      controllers = data.is_a?(Hash) ? data[:controller] : nil
+      return unless controllers.is_a?(String) && !controllers.empty?
+
+      id = attrs[:id]
+      return if id.is_a?(String) && !id.empty?
+
+      attrs[:id] = generate_id("hakumi-component")
+    end
+
+    sig { params(prefix: String, length: Integer).returns(String) }
+    def generate_id(prefix, length: 4)
+      "#{prefix}_#{SecureRandom.hex(length)}"
+    end
+
+    sig { params(value: Types::Renderable).returns(Types::RenderedContent) }
+    def render_value(value)
+      return nil unless value.present?
+      return value if value.is_a?(String) || value.is_a?(ActiveSupport::SafeBuffer)
+      return value.to_s if value.is_a?(ViewComponent::Slot)
+      return render(value) if value.respond_to?(:render_in)
+
+      nil
+    end
+
+    sig { params(size: SizeValue, mapping: T::Hash[Symbol, Integer]).returns(SizeValue) }
+    def size_to_pixels(size, mapping = {})
+      return size if size.is_a?(Integer)
+      mapping[size.to_sym] || size
+    end
+
+    sig { params(value: DimensionInput).returns(T.nilable(String)) }
+    def dimension_to_css(value)
+      return nil if value.nil?
+      return value if value.is_a?(String) && value.strip.present?
+      return "#{value}px" if value.is_a?(Numeric)
+
+      string = value.to_s.strip
+      string.empty? ? nil : string
+    end
+
+    sig { params(controller: String, values: Types::StimulusValues).returns(Types::StimulusData) }
+    def stimulus_attrs(controller, values = {})
+      data = T.let({ "controller" => controller }, Types::StimulusData)
+      values.each do |key, value|
+        next if value.nil?
+
+        serialized = value.is_a?(Array) || value.is_a?(Hash) ? value.to_json : value
+        data["#{controller}-#{key.to_s.underscore.dasherize}-value"] = serialized
+      end
+      data
+    end
+
+    sig { params(value: Types::HtmlAttributeValue).returns(Types::DataAttributes) }
+    def data_attributes_from(value)
+      attrs = T.let({}, Types::DataAttributes)
+      return attrs unless value.is_a?(Hash)
+
+      value.each do |key, entry|
+        attrs[key] = entry
+      end
+      attrs
+    end
+
+    sig { params(existing: Types::HtmlAttributeValue, token: String).returns(String) }
+    def append_data_token(existing, token)
+      return token unless existing.is_a?(String) && existing.present?
+
+      [ existing, token ].join(" ")
+    end
+
+    BOOLEAN_CASTER = T.let(ActiveModel::Type::Boolean.new.freeze, ActiveModel::Type::Boolean)
+    private_constant :BOOLEAN_CASTER
+
+    sig { params(value: Types::HtmlPrimitive).returns(T.nilable(T::Boolean)) }
+    def self.cast_boolean(value)
+      BOOLEAN_CASTER.cast(value)
+    end
+
+    sig { params(value: Types::HtmlAttributeValue).returns(Types::HtmlPrimitive) }
+    def self.html_primitive_param(value)
+      return value if value.is_a?(String)
+      return value if value.is_a?(Symbol)
+      return value if value.is_a?(TrueClass)
+      return value if value.is_a?(FalseClass)
+      return value if value.is_a?(Numeric)
+
+      nil
+    end
+
+      sig do
+      params(
+        params: ControllerOptions,
+        key: Symbol
+      ).returns(Types::HtmlAttributeValue)
+    end
+    def self.html_param(params, key)
+      coerce_html_attribute_value(params[key])
+    end
+
+    sig { params(value: Types::HtmlAttributeValue).returns(T.nilable(T::Boolean)) }
+    def self.boolean_html_param(value)
+      scalar = html_primitive_param(value)
+      return nil if scalar.nil?
+
+      cast_boolean(scalar)
+    end
+
+    sig { params(value: Types::HtmlAttributeValue).returns(T.nilable(Symbol)) }
+    def self.symbol_html_param(value)
+      return value.to_sym if value.is_a?(String) || value.is_a?(Symbol)
+
+      nil
+    end
+
+    sig { params(value: Types::HtmlAttributeValue).returns(T.nilable(Integer)) }
+    def self.integer_html_param(value)
+      return value if value.is_a?(Integer)
+      return value.to_i if value.is_a?(String)
+
+      nil
+    end
+
+    sig { params(value: Types::HtmlAttributeValue).returns(T.nilable(Float)) }
+    def self.float_html_param(value)
+      return value.to_f if value.is_a?(String)
+      return value.to_f if value.is_a?(Numeric)
+
+      nil
+    end
+
+    sig { params(value: Types::HtmlAttributeValue).returns(T.nilable(String)) }
+    def self.string_html_param(value)
+      return nil if value.nil?
+      return value if value.is_a?(String)
+      return value.to_s if value.is_a?(Symbol) || value.is_a?(Numeric)
+
+      nil
+    end
+
+    sig { params(value: Types::HtmlAttributeValue).returns(T.nilable(Types::StringOrSymbolArray)) }
+    def self.string_or_symbol_array_html_param(value)
+      return nil unless value.is_a?(Array)
+
+      entries = T.let([], Types::StringOrSymbolArray)
+      value.each do |entry|
+        next if entry.nil?
+
+        entries << entry
+      end
+      entries
+    end
+
+    class << self
+      extend T::Sig
+
+      private
+
+      sig { params(value: RawHtmlInput).returns(Types::HtmlPrimitive) }
+      def coerce_html_primitive(value)
+        return value if value.is_a?(String)
+        return value if value.is_a?(Symbol)
+        return value if value.is_a?(TrueClass)
+        return value if value.is_a?(FalseClass)
+        return value if value.is_a?(Numeric)
+
+        nil
+      end
+
+      sig { params(value: RawHtmlInput).returns(Types::HtmlAttributeValue) }
+      def coerce_html_attribute_value(value)
+        primitive = coerce_html_primitive(value)
+        return primitive unless primitive.nil?
+
+        if value.is_a?(Array)
+          entries = T.let([], T::Array[T.nilable(String)])
+          value.each do |entry|
+            entries << entry if entry.nil? || entry.is_a?(String)
+          end
+          return entries
+        end
+
+        source_hash = if value.is_a?(ActionController::Parameters)
+          value.to_unsafe_h
+        elsif value.is_a?(Hash)
+          value
+        end
+
+        if source_hash
+          attrs = T.let({}, Types::DataAttributes)
+          source_hash.each do |entry_key, entry_value|
+            entry_primitive = coerce_html_primitive(entry_value)
+            attrs[entry_key] = entry_primitive
+          end
+          return attrs
+        end
+
+        nil
+      end
+    end
+
+    sig { params(value: Types::HtmlPrimitive).returns(T.nilable(T::Boolean)) }
+    def cast_boolean(value)
+      self.class.cast_boolean(value)
+    end
+
+    sig { params(styles: T.nilable(Types::StyleValue)).returns(T.nilable(String)) }
+    def build_inline_style(styles)
+      return nil if styles.respond_to?(:blank?) && styles.blank?
+
+      style_array = if styles.is_a?(Hash)
+        styles.compact.map { |key, value| "#{key}: #{value}" }
+      else
+        Array(styles).compact
+      end
+
+      return nil if style_array.empty?
+      style_array.join("; ")
+    end
+
+    sig { params(attributes: Types::HtmlAttributes).returns(Types::CssClasses) }
+    def html_classes(attributes)
+      value = attributes[:class]
+      return value if value.is_a?(String) || value.is_a?(Array)
+
+      nil
+    end
+
+    sig { params(base: String, modifiers: Types::ClassModifiers, attributes: Types::HtmlAttributes).returns(String) }
+    def component_classes(base, modifiers = {}, attributes = {})
+      class_names(base, modifiers, html_classes(attributes))
+    end
+
+    sig { params(attributes: Types::HtmlAttributes).returns(T.nilable(String)) }
+    def html_style(attributes)
+      value = attributes[:style]
+      value.is_a?(String) ? value : nil
+    end
+
+    sig { params(key: Types::HtmlKey, default: String, options: I18nOptionValue).returns(String) }
+    def translate_with_default(key, default:, **options)
+      I18n.t(key, scope: i18n_scope, default: default, **options)
+    end
+
+    sig { params(key: Types::HtmlKey, default: String, options: I18nOptionValue).returns(String) }
+    def t_default(key, default:, **options)
+      I18n.t(key, scope: i18n_scope, default: default, **options)
+    end
+
+    sig { returns(String) }
+    def i18n_scope
+      @i18n_scope = T.let(@i18n_scope, T.nilable(String)) unless instance_variable_defined?(:@i18n_scope)
+      @i18n_scope ||= begin
+        class_name = self.class.name
+        raise "#{self.class} must have a name for i18n scope" if class_name.nil?
+
+        class_name
+        .delete_suffix("::Component")
+        .underscore
+        .tr("/", ".")
+      end
+    end
+
+    private
+
+    sig do
+      params(
+        defaults: Types::HtmlAttributeValue,
+        overrides: Types::HtmlAttributeValue
+      ).returns(T.nilable(Types::DataAttributes))
+    end
+    def merge_attribute_hash(defaults, overrides)
+      return defaults if defaults.is_a?(Hash) && !overrides.is_a?(Hash)
+      return overrides if overrides.is_a?(Hash) && !defaults.is_a?(Hash)
+      return nil unless defaults.is_a?(Hash) && overrides.is_a?(Hash)
+
+      merged = T.let({}, Types::DataAttributes)
+      defaults.each { |key, value| merged[key] = value }
+      overrides.each { |key, value| merged[key] = value }
+      merged
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Breadcrumb
+    class Component < HakumiComponents::BaseComponent
+      extend T::Sig
+
+      renders_many :items, ->(title: nil, href: nil, target: nil, **options, &block) do
+        HakumiComponents::Breadcrumb::Item::Component.new(title: title, href: href, target: target, **options)
+      end
+
+      sig do
+        params(
+          separator: String,
+          html_options: Types::HtmlAttributeValue
+        ).void
+      end
+      def initialize(separator: "/", **html_options)
+        @separator = T.let(separator, String)
+        @html_options = T.let(html_options, Types::HtmlAttributes)
+      end
+
+      sig { returns(String) }
+      attr_reader :separator
+
+      sig { returns(String) }
+      def breadcrumb_classes
+        "hakumi-breadcrumb"
+      end
+
+      sig { returns(Types::HtmlAttributes) }
+      def wrapper_attributes
+        merge_attributes({ class: breadcrumb_classes }, @html_options)
+      end
+    end
+  end
+end

data/app/components/hakumi_components/breadcrumb/item/component.html.erb

@@ -0,0 +1,17 @@
+<% if menu? %>
+  <%= render HakumiComponents::Dropdown::Component.new do |dropdown| %>
+    <% dropdown.with_trigger do %>
+      <%= tag.span(**item_attributes(extra_classes: ["hakumi-breadcrumb-link-dropdown"])) do %>
+        <%= display_title %>
+        <%= render HakumiComponents::Icon::Component.new(name: :down, size: 10) %>
+      <% end %>
+    <% end %>
+    <% menu.each do |item| %>
+      <% dropdown.with_item(key: item.key, label: item.title, href: item.href, target: item.target) %>
+    <% end %>
+  <% end %>
+<% elsif link? %>
+  <%= tag.a(display_title, **link_attributes) %>
+<% else %>
+  <%= tag.span(display_title, **item_attributes) %>
+<% end %>

data/app/components/hakumi_components/breadcrumb/item/component.rb

@@ -0,0 +1,83 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Breadcrumb
+    module Item
+      class Component < HakumiComponents::BaseComponent
+        extend T::Sig
+
+        sig do
+          params(
+            title: T.nilable(String),
+            href: T.nilable(String),
+            target: T.nilable(String),
+            menu: T.nilable(T::Array[T.any(HakumiComponents::Breadcrumb::Item::MenuEntry, Types::HtmlAttributes)]),
+            html_options: Types::HtmlAttributeValue
+          ).void
+        end
+        def initialize(title: nil, href: nil, target: nil, menu: nil, **html_options)
+          @title = T.let(title, T.nilable(String))
+          @href = T.let(href, T.nilable(String))
+          @target = T.let(target, T.nilable(String))
+          @menu = T.let(
+            HakumiComponents::Breadcrumb::Item::MenuEntry.coerce_all(menu),
+            T.nilable(T::Array[HakumiComponents::Breadcrumb::Item::MenuEntry])
+          )
+          @html_options = T.let(html_options, Types::HtmlAttributes)
+        end
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :title
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :href
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :target
+
+        sig { returns(T.nilable(T::Array[HakumiComponents::Breadcrumb::Item::MenuEntry])) }
+        attr_reader :menu
+
+        sig { returns(String) }
+        def item_classes
+          "hakumi-breadcrumb-link"
+        end
+
+        sig { params(extra_classes: T::Array[String]).returns(Types::HtmlAttributes) }
+        def item_attributes(extra_classes: [])
+          merge_attributes(
+            { class: ([ item_classes ] + extra_classes).join(" ") },
+            @html_options
+          )
+        end
+
+        sig { returns(Types::HtmlAttributes) }
+        def link_attributes
+          attrs = item_attributes
+          attrs[:href] = href
+          attrs[:target] = target if target.present?
+          attrs
+        end
+
+        sig { returns(T::Boolean) }
+        def link?
+          href.present?
+        end
+
+        sig { returns(T::Boolean) }
+        def menu?
+          m = @menu
+          return false if m.nil?
+
+          m.any?
+        end
+
+        sig { returns(Types::RenderedContent) }
+        def display_title
+          content.presence || @title
+        end
+      end
+    end
+  end
+end

data/app/components/hakumi_components/breadcrumb/item/menu_entry.rb

@@ -0,0 +1,71 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Breadcrumb
+    module Item
+      class MenuEntry
+        extend T::Sig
+
+        sig do
+          params(
+            title: String,
+            href: T.nilable(String),
+            target: T.nilable(String),
+            key: T.nilable(String)
+          ).void
+        end
+        def initialize(title:, href: nil, target: nil, key: nil)
+          @title = T.let(title, String)
+          @href = T.let(href, T.nilable(String))
+          @target = T.let(target, T.nilable(String))
+          @key = T.let(key || title, String)
+        end
+
+        sig { returns(String) }
+        attr_reader :title, :key
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :href, :target
+
+        sig do
+          params(
+            entries: T.nilable(T::Array[T.any(HakumiComponents::Breadcrumb::Item::MenuEntry, Types::HtmlAttributes)])
+          ).returns(T.nilable(T::Array[HakumiComponents::Breadcrumb::Item::MenuEntry]))
+        end
+        def self.coerce_all(entries)
+          return nil if entries.nil?
+
+          coerced = T.let([], T::Array[HakumiComponents::Breadcrumb::Item::MenuEntry])
+          entries.each do |entry|
+            coerced << coerce(entry)
+          end
+          coerced
+        end
+
+        sig do
+          params(
+            entry: T.any(HakumiComponents::Breadcrumb::Item::MenuEntry, Types::HtmlAttributes)
+          ).returns(HakumiComponents::Breadcrumb::Item::MenuEntry)
+        end
+        def self.coerce(entry)
+          return entry if entry.is_a?(HakumiComponents::Breadcrumb::Item::MenuEntry)
+
+          title = entry[:title]
+          href = entry[:href]
+          target = entry[:target]
+          key = entry[:key]
+
+          raise ArgumentError, "menu entry title is required" unless title.is_a?(String) && title.present?
+
+          new(
+            title: title,
+            href: href.is_a?(String) ? href : nil,
+            target: target.is_a?(String) ? target : nil,
+            key: key.is_a?(String) ? key : nil
+          )
+        end
+      end
+    end
+  end
+end