hakumi_components 0.1.18.pre → 0.1.19.pre

data/app/components/hakumi_components/skeleton/avatar_config.rb

@@ -0,0 +1,79 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Skeleton
+    class AvatarConfig
+      extend T::Sig
+
+      Size = T.type_alias { T.any(Symbol, Numeric) }
+      ShapeInput = T.type_alias { T.any(Symbol, String) }
+      Input = T.type_alias { T.any(T::Boolean, Types::HtmlAttributes, HakumiComponents::Skeleton::AvatarConfig) }
+      SHAPES = T.let(%i[circle square].freeze, T::Array[Symbol])
+
+      sig { params(size: Size, shape: Symbol).void }
+      def initialize(size: :default, shape: :circle)
+        @size = T.let(normalize_size(size), Size)
+        @shape = T.let(normalize_shape(shape), Symbol)
+        validate!
+      end
+
+      sig { returns(Size) }
+      attr_reader :size
+
+      sig { returns(Symbol) }
+      attr_reader :shape
+
+      sig { params(value: Input).returns(T.nilable(HakumiComponents::Skeleton::AvatarConfig)) }
+      def self.coerce(value)
+        return nil if value == false
+        return new if value == true
+        return value if value.is_a?(HakumiComponents::Skeleton::AvatarConfig)
+
+        size = value[:size]
+        shape = value[:shape]
+        resolved_size = if size.is_a?(Symbol) || size.is_a?(Numeric)
+          size
+        elsif size.is_a?(String)
+          size.to_sym
+        else
+          :default
+        end
+        resolved_shape = if shape.is_a?(Symbol)
+          shape
+        elsif shape.is_a?(String)
+          shape.to_sym
+        else
+          :circle
+        end
+
+        new(size: resolved_size, shape: resolved_shape)
+      end
+
+      private
+
+      sig { params(size: Size).returns(Size) }
+      def normalize_size(size)
+        return size if size.is_a?(Numeric)
+
+        size.to_sym
+      end
+
+      sig { params(shape: ShapeInput).returns(Symbol) }
+      def normalize_shape(shape)
+        shape.to_sym
+      end
+
+      sig { void }
+      def validate!
+        allowed_sizes = HakumiComponents::BaseComponent::SIZES
+        if !@size.is_a?(Numeric) && !allowed_sizes.include?(@size)
+          raise ArgumentError, "avatar size must be one of #{allowed_sizes.inspect}, got #{@size.inspect}"
+        end
+        return if SHAPES.include?(@shape)
+
+        raise ArgumentError, "avatar shape must be one of #{SHAPES.inspect}, got #{@shape.inspect}"
+      end
+    end
+  end
+end

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

@@ -1,54 +1,72 @@
+# typed: strict
 # frozen_string_literal: true
 
 module HakumiComponents
   module Skeleton
     module Button
       class Component < HakumiComponents::BaseComponent
-        SIZES = [ :small, :default, :large ].freeze
-        SHAPES = [ :default, :circle, :round ].freeze
+        extend T::Sig
 
+        SHAPES = T.let(%i[default circle round].freeze, T::Array[Symbol])
+
+        sig do
+          params(
+            active: T::Boolean,
+            size: T.any(Symbol, String),
+            shape: T.any(Symbol, String),
+            block: T::Boolean,
+            html_options: Types::HtmlAttributeValue
+          ).void
+        end
         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
+          @active = T.let(active, T::Boolean)
+          @size = T.let(normalize_size(size), Symbol)
+          @shape = T.let(normalize_shape(shape), Symbol)
+          @block = T.let(block, T::Boolean)
+          @html_options = T.let(html_options, Types::HtmlAttributes)
 
           validate_props!
         end
 
+        sig { returns(Types::HtmlAttributes) }
         def wrapper_attributes
           merge_attributes({ class: wrapper_classes }, @html_options.except(:class))
         end
 
+        sig { returns(String) }
         def button_classes
-          modifiers = {}
-          modifiers[@size] = true if @size && @size != :default
-          modifiers[@shape] = true if @shape && @shape != :default
+          modifiers = T.let({}, Types::ClassModifiers)
+          modifiers[@size] = true if @size != :default
+          modifiers[@shape] = true if @shape != :default
 
           class_names("skeleton-button", modifiers)
         end
 
         private
 
+        sig { params(size: T.any(Symbol, String)).returns(Symbol) }
         def normalize_size(size)
           size.to_sym
         end
 
+        sig { params(shape: T.any(Symbol, String)).returns(Symbol) }
         def normalize_shape(shape)
           shape.to_sym
         end
 
+        sig { returns(String) }
         def wrapper_classes
-          class_names("skeleton", { element: true, active: @active, block: @block }, @html_options[:class])
+          component_classes("skeleton", { element: true, active: @active, block: @block }, @html_options)
         end
 
+        sig { void }
         def validate_props!
-          validate_inclusion_value(:size, @size, SIZES) if @size
-          validate_inclusion_value(:shape, @shape, SHAPES) if @shape
+          validate_inclusion_value(name: :size, value: @size, allowed: SIZES)
+          validate_inclusion_value(name: :shape, value: @shape, allowed: SHAPES)
         end
 
-        def validate_inclusion_value(name, value, allowed)
+        sig { params(name: Symbol, value: Symbol, allowed: T::Array[Symbol]).void }
+        def validate_inclusion_value(name:, value:, allowed:)
           return if allowed.include?(value)
 
           raise ArgumentError, "#{name} must be one of #{allowed.inspect}, got #{value.inspect}"

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

@@ -1,26 +1,51 @@
+# typed: strict
 # frozen_string_literal: true
 
 module HakumiComponents
   module Skeleton
     class Component < HakumiComponents::BaseComponent
-      AVATAR_SIZES = [ :small, :default, :large ].freeze
-      AVATAR_SHAPES = [ :circle, :square ].freeze
-      DEFAULT_PARAGRAPH_ROWS = 3
-
+      extend T::Sig
+
+      ConfigToggle = T.type_alias { T::Boolean }
+      ConfigInput = T.type_alias { T.any(ConfigToggle, Types::HtmlAttributes) }
+      ConfigParam = T.type_alias { T.any(ActionController::Parameters, Types::HtmlAttributeValue) }
+      ConfigValue = T.type_alias { T.nilable(T.any(ConfigToggle, Types::HtmlAttributes)) }
+      AvatarInput = T.type_alias { T.any(ConfigInput, HakumiComponents::Skeleton::AvatarConfig) }
+      TitleInput = T.type_alias { T.any(ConfigInput, HakumiComponents::Skeleton::TitleConfig) }
+      ParagraphInput = T.type_alias { T.any(ConfigInput, HakumiComponents::Skeleton::ParagraphConfig) }
+      DEFAULT_PARAGRAPH_ROWS = T.let(3, Integer)
+
+      sig { params(params: BaseComponent::ControllerOptions).returns(T::Hash[Symbol, ConfigValue]) }
       def self.extract_controller_locals(params)
+        loading_value = html_param(params, :loading)
+        avatar_value = html_param(params, :avatar)
+        title_value = html_param(params, :title)
+        paragraph_value = html_param(params, :paragraph)
+
         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])
+          loading: loading_value.nil? ? true : boolean_html_param(loading_value) != false,
+          active: boolean_html_param(html_param(params, :active)) == true,
+          round: boolean_html_param(html_param(params, :round)) == true
         }
 
-        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[:avatar] = normalize_config_param(avatar_value) unless avatar_value.nil?
+        locals[:title] = normalize_config_param(title_value) unless title_value.nil?
+        locals[:paragraph] = normalize_config_param(paragraph_value) unless paragraph_value.nil?
 
         locals
       end
 
+      sig do
+        params(
+          loading: T::Boolean,
+          active: T::Boolean,
+          avatar: AvatarInput,
+          title: TitleInput,
+          paragraph: ParagraphInput,
+          round: T::Boolean,
+          html_options: Types::HtmlAttributeValue
+        ).void
+      end
       def initialize(
         loading: true,
         active: false,
@@ -30,21 +55,21 @@ module HakumiComponents
         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!
+        @loading = T.let(loading, T::Boolean)
+        @active = T.let(active, T::Boolean)
+        @round = T.let(round, T::Boolean)
+        @avatar = T.let(HakumiComponents::Skeleton::AvatarConfig.coerce(avatar), T.nilable(HakumiComponents::Skeleton::AvatarConfig))
+        @title = T.let(HakumiComponents::Skeleton::TitleConfig.coerce(title), T.nilable(HakumiComponents::Skeleton::TitleConfig))
+        @paragraph = T.let(HakumiComponents::Skeleton::ParagraphConfig.coerce(paragraph), T.nilable(HakumiComponents::Skeleton::ParagraphConfig))
+        @html_options = T.let(html_options, Types::HtmlAttributes)
       end
 
+      sig { returns(T::Boolean) }
       def loading?
         @loading
       end
 
+      sig { returns(Types::HtmlAttributes) }
       def wrapper_attributes
         merge_attributes(
           { class: wrapper_classes },
@@ -52,94 +77,85 @@ module HakumiComponents
         )
       end
 
+      sig { returns(T::Boolean) }
       def avatar?
         !@avatar.nil?
       end
 
+      sig { returns(T::Boolean) }
       def title?
         !@title.nil?
       end
 
+      sig { returns(T::Boolean) }
       def paragraph?
         !@paragraph.nil?
       end
 
+      sig { returns(String) }
       def avatar_classes
         modifiers = {}
-        modifiers[avatar_size] = true if avatar_size && avatar_size != :default
+        modifiers[avatar_size] = true if avatar_size != :default
         modifiers[avatar_shape] = true if avatar_shape
 
         class_names("skeleton-avatar", modifiers)
       end
 
+      sig { returns(T.nilable(String)) }
       def avatar_style
         return nil unless avatar_size.is_a?(Numeric)
 
         "width: #{avatar_size}px; height: #{avatar_size}px;"
       end
 
+      sig { returns(T.nilable(String)) }
       def title_style
-        width = dimension_to_css(@title&.dig(:width))
+        width = @title.nil? ? nil : dimension_to_css(@title.width)
         return nil unless width
 
         "width: #{width};"
       end
 
+      sig { returns(T::Array[T.nilable(String)]) }
       def paragraph_row_widths
         return [] unless paragraph?
+        paragraph = @paragraph
+        return [] if paragraph.nil?
 
-        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) }
+        paragraph.row_widths(DEFAULT_PARAGRAPH_ROWS).map { |value| dimension_to_css(value) }
       end
 
+      sig { params(width: T.nilable(String)).returns(T.nilable(String)) }
       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
 
+      sig { params(value: ConfigParam).returns(ConfigValue) }
       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)
+        if value.is_a?(ActionController::Parameters) || value.is_a?(Hash)
+          source = value.is_a?(ActionController::Parameters) ? value.to_unsafe_h : value
+          attrs = T.let({}, Types::HtmlAttributes)
+          source.each do |key, entry|
+            next unless key.is_a?(String) || key.is_a?(Symbol)
+            next unless entry.nil? || entry.is_a?(String) || entry.is_a?(Symbol) || entry.is_a?(TrueClass) || entry.is_a?(FalseClass) || entry.is_a?(Numeric) || entry.is_a?(Hash) || entry.is_a?(Array)
 
-        ActiveModel::Type::Boolean.new.cast(value)
-      end
-
-      def normalize_config(value)
-        return nil if value.nil? || value == false
-        return {} if value == true
+            attrs[key.to_sym] = entry
+          end
+          return attrs
+        end
 
-        return value.to_h.symbolize_keys if value.respond_to?(:to_h)
+        return cast_boolean(value) if value.is_a?(String) || value.is_a?(Symbol) || value.is_a?(TrueClass) || value.is_a?(FalseClass) || value.is_a?(Numeric)
 
-        {}
+        nil
       end
 
+      sig { returns(String) }
       def wrapper_classes
         modifiers = {
           active: @active,
@@ -149,51 +165,21 @@ module HakumiComponents
           round: @round
         }
 
-        class_names("skeleton", modifiers, @html_options[:class])
+        component_classes("skeleton", modifiers, @html_options)
       end
 
+      sig { returns(T.any(Symbol, Numeric)) }
       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
+        return :default if @avatar.nil?
 
-      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
+        @avatar.size
       end
 
-      def validate_inclusion_value(name, value, allowed)
-        return if allowed.include?(value)
+      sig { returns(Symbol) }
+      def avatar_shape
+        return :circle if @avatar.nil?
 
-        raise ArgumentError, "#{name} must be one of #{allowed.inspect}, got #{value.inspect}"
+        @avatar.shape
       end
     end
   end

data/app/components/hakumi_components/skeleton/image/component.rb

@@ -1,39 +1,57 @@
+# typed: strict
 # frozen_string_literal: true
 
 module HakumiComponents
   module Skeleton
     module Image
       class Component < HakumiComponents::BaseComponent
-        DEFAULT_ICON_NAME = "picture"
-        DEFAULT_ICON_THEME = :outlined
-        DEFAULT_ICON_SIZE = 48
-        ICON_SCALE = 0.55
-        MIN_ICON_SIZE = 32
-
+        extend T::Sig
+
+        SizeInput = T.type_alias { BaseComponent::DimensionInput }
+        DEFAULT_ICON_NAME = T.let("picture", String)
+        DEFAULT_ICON_THEME = T.let(:outlined, Symbol)
+        DEFAULT_ICON_SIZE = T.let(48, Integer)
+        ICON_SCALE = T.let(0.55, Float)
+        MIN_ICON_SIZE = T.let(32, Integer)
+
+        sig do
+          params(
+            active: T::Boolean,
+            width: SizeInput,
+            height: SizeInput,
+            html_options: Types::HtmlAttributeValue
+          ).void
+        end
         def initialize(active: false, width: 96, height: 96, **html_options)
-          @active = active
-          @width = width
-          @height = height
-          @html_options = html_options
+          @active = T.let(active, T::Boolean)
+          @width = T.let(width, SizeInput)
+          @height = T.let(height, SizeInput)
+          @html_options = T.let(html_options, Types::HtmlAttributes)
 
           validate_props!
         end
 
+        sig { returns(Types::HtmlAttributes) }
         def wrapper_attributes
           merge_attributes({ class: wrapper_classes }, @html_options.except(:class))
         end
 
+        sig { returns(String) }
         def image_classes
           class_names("skeleton-image")
         end
 
+        sig { returns(T.nilable(String)) }
         def image_style
-          styles = []
-          styles << "width: #{dimension_to_css(@width)}" if @width
-          styles << "height: #{dimension_to_css(@height)}" if @height
-          styles.join("; ") if styles.any?
+          styles = T.let([], T::Array[String])
+          width_css = dimension_to_css(@width)
+          height_css = dimension_to_css(@height)
+          styles << "width: #{width_css}" if width_css
+          styles << "height: #{height_css}" if height_css
+          styles.any? ? styles.join("; ") : nil
         end
 
+        sig { returns(Types::HtmlAttributes) }
         def icon_component_options
           {
             name: DEFAULT_ICON_NAME,
@@ -46,31 +64,37 @@ module HakumiComponents
 
         private
 
+        sig { returns(Integer) }
         def calculated_icon_size
           dimension = [ numeric_dimension(@width), numeric_dimension(@height) ].compact.min
           return DEFAULT_ICON_SIZE unless dimension
 
-          [ (dimension * ICON_SCALE).round, MIN_ICON_SIZE ].max
+          scaled = (dimension * ICON_SCALE).round.to_i
+          scaled > MIN_ICON_SIZE ? scaled : MIN_ICON_SIZE
         end
 
+        sig { params(value: SizeInput).returns(T.nilable(Numeric)) }
         def numeric_dimension(value)
           return value if value.is_a?(Numeric)
-          return value.to_f if value.is_a?(String) && value.strip.end_with?("px")
+          return nil unless value.is_a?(String)
 
-          nil
+          value.strip.end_with?("px") ? value.to_f : nil
         end
 
+        sig { returns(String) }
         def wrapper_classes
-          class_names("skeleton", { element: true, active: @active }, @html_options[:class])
+          component_classes("skeleton", { element: true, active: @active }, @html_options)
         end
 
+        sig { void }
         def validate_props!
-          validate_size!(:width, @width)
-          validate_size!(:height, @height)
+          validate_size!(name: :width, value: @width)
+          validate_size!(name: :height, value: @height)
         end
 
-        def validate_size!(name, value)
-          return if value.nil? || value.is_a?(Numeric) || value.is_a?(String)
+        sig { params(name: Symbol, value: SizeInput).void }
+        def validate_size!(name:, value:)
+          return if value.is_a?(Numeric) || value.is_a?(String)
 
           raise ArgumentError, "#{name} must be a number or string"
         end

data/app/components/hakumi_components/skeleton/input/component.rb

@@ -1,46 +1,61 @@
+# typed: strict
 # frozen_string_literal: true
 
 module HakumiComponents
   module Skeleton
     module Input
       class Component < HakumiComponents::BaseComponent
-        SIZES = [ :small, :default, :large ].freeze
+        extend T::Sig
 
+        sig do
+          params(
+            active: T::Boolean,
+            size: T.any(Symbol, String),
+            block: T::Boolean,
+            html_options: Types::HtmlAttributeValue
+          ).void
+        end
         def initialize(active: false, size: :default, block: false, **html_options)
-          @active = active
-          @size = normalize_size(size)
-          @block = block
-          @html_options = html_options
+          @active = T.let(active, T::Boolean)
+          @size = T.let(normalize_size(size), Symbol)
+          @block = T.let(block, T::Boolean)
+          @html_options = T.let(html_options, Types::HtmlAttributes)
 
           validate_props!
         end
 
+        sig { returns(Types::HtmlAttributes) }
         def wrapper_attributes
           merge_attributes({ class: wrapper_classes }, @html_options.except(:class))
         end
 
+        sig { returns(String) }
         def input_classes
-          modifiers = {}
-          modifiers[@size] = true if @size && @size != :default
+          modifiers = T.let({}, Types::ClassModifiers)
+          modifiers[@size] = true if @size != :default
 
           class_names("skeleton-input", modifiers)
         end
 
         private
 
+        sig { params(size: T.any(Symbol, String)).returns(Symbol) }
         def normalize_size(size)
           size.to_sym
         end
 
+        sig { returns(String) }
         def wrapper_classes
-          class_names("skeleton", { element: true, active: @active, block: @block }, @html_options[:class])
+          component_classes("skeleton", { element: true, active: @active, block: @block }, @html_options)
         end
 
+        sig { void }
         def validate_props!
-          validate_inclusion_value(:size, @size, SIZES) if @size
+          validate_inclusion_value(name: :size, value: @size, allowed: SIZES)
         end
 
-        def validate_inclusion_value(name, value, allowed)
+        sig { params(name: Symbol, value: Symbol, allowed: T::Array[Symbol]).void }
+        def validate_inclusion_value(name:, value:, allowed:)
           return if allowed.include?(value)
 
           raise ArgumentError, "#{name} must be one of #{allowed.inspect}, got #{value.inspect}"