hakumi_components 0.1.18.pre → 0.1.19.pre

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

@@ -1,14 +1,16 @@
+# typed: strict
 # frozen_string_literal: true
 
 module HakumiComponents
   module Descriptions
-    # Hakumi Descriptions component
-    # Displays multiple read-only fields in a group.
     class Component < HakumiComponents::BaseComponent
-      SIZE_OPTIONS = [ :default, :middle, :small ].freeze
-      LAYOUT_OPTIONS = [ :horizontal, :vertical ].freeze
+      extend T::Sig
 
-      COLUMN_BREAKPOINTS = [ :xs, :sm, :md, :lg, :xl, :xxl ].freeze
+      LAYOUTS = T.let(%i[horizontal vertical].freeze, T::Array[Symbol])
+      COLUMN_BREAKPOINTS = T.let(%i[xs sm md lg xl xxl].freeze, T::Array[Symbol])
+
+      renders_one :title
+      renders_one :extra
 
       renders_many :items, ->(
         label:,
@@ -16,7 +18,6 @@ module HakumiComponents
         span: 1,
         label_style: nil,
         content_style: nil,
-        **options,
         &block
       ) do
         item = HakumiComponents::Descriptions::Item::Component.new(
@@ -24,13 +25,24 @@ module HakumiComponents
           content: content,
           span: span,
           label_style: label_style,
-          content_style: content_style,
-          **options
+          content_style: content_style
         )
         item.content = capture(&block) if block
         item
       end
 
+      sig do
+        params(
+          title: Types::Renderable,
+          extra: Types::Renderable,
+          bordered: T::Boolean,
+          size: Symbol,
+          layout: Symbol,
+          column: T.any(Integer, T::Hash[Symbol, Integer]),
+          colon: T::Boolean,
+          html_options: Types::HtmlAttributeValue
+        ).void
+      end
       def initialize(
         title: nil,
         extra: nil,
@@ -41,46 +53,76 @@ module HakumiComponents
         colon: true,
         **html_options
       )
-        @title = title
-        @extra = extra
-        @bordered = bordered
-        @size = size
-        @layout = layout
-        @column = column
-        @colon = colon
-        @html_options = html_options
+        @title = T.let(title, Types::Renderable)
+        @extra = T.let(extra, Types::Renderable)
+        @bordered = T.let(cast_boolean(bordered) ? true : false, T::Boolean)
+        @size = T.let(size.to_sym, Symbol)
+        @layout = T.let(layout.to_sym, Symbol)
+        @column = T.let(normalize_column(column), T.any(Integer, T::Hash[Symbol, Integer]))
+        @colon = T.let(cast_boolean(colon) != false, 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)
+      end
+
+      sig { returns(T::Boolean) }
+      def header?
+        title_content.present? || extra_content.present?
+      end
+
+      sig { returns(T::Boolean) }
+      def vertical_layout?
+        @layout == :vertical
+      end
+
+      sig { returns(Types::RenderedContent) }
+      def title_content
+        return render_value(title) if title?
+
+        render_value(@title)
+      end
+
+      sig { returns(Types::RenderedContent) }
+      def extra_content
+        return render_value(extra) if extra?
+
+        render_value(@extra)
+      end
+
       private
 
+      sig { void }
       def validate_props!
-        validate_inclusion!(:size, SIZE_OPTIONS)
-        validate_inclusion!(:layout, LAYOUT_OPTIONS)
+        validate_inclusion!(:size, SIZES)
+        validate_inclusion!(:layout, LAYOUTS)
       end
 
+      sig { returns(Integer) }
       def max_column_count
-        case @column
-        when Integer
+        if @column.is_a?(Integer)
           @column.positive? ? @column : 3
-        when Hash
-          values = @column.values.compact
-          values.empty? ? 3 : values.max
         else
-          3
+          values = @column.values
+          return 3 if values.empty?
+
+          values.reduce(0) { |max, value| value > max ? value : max }
         end
       end
 
+      sig { returns(T::Array[T::Array[[ HakumiComponents::Descriptions::Item::Component, Integer ]]]) }
       def rows
         cols = max_column_count
-        result = []
-        current_row = []
-        current_span = 0
+        result = T.let([], T::Array[T::Array[[ HakumiComponents::Descriptions::Item::Component, Integer ]]])
+        current_row = T.let([], T::Array[[ HakumiComponents::Descriptions::Item::Component, Integer ]])
+        current_span = T.let(0, Integer)
 
         items.each do |item|
-          span = item.span.to_i
-          span = 1 if span <= 0
+          span = item.span.positive? ? item.span : 1
           span = cols if span > cols
 
           if current_span + span > cols && !current_row.empty?
@@ -95,36 +137,44 @@ module HakumiComponents
 
         result << current_row unless current_row.empty?
 
-        # Fill remaining space in the last row by extending the last item's span
         result.map do |row|
           total_span = row.sum { |(_, span)| span }
           if total_span < cols && !row.empty?
             remaining = cols - total_span
-            last_item, last_span = row.last
-            row[0...-1] + [ [ last_item, last_span + remaining ] ]
+            last_item, last_span = row.fetch(row.length - 1)
+            prefix = row[0, row.length - 1] || []
+            prefix + [ [ last_item, last_span + remaining ] ]
           else
             row
           end
         end
       end
 
+      sig { returns(String) }
       def wrapper_classes
-        column_classes = build_column_classes
+        extras = T.let(build_column_classes, T::Array[String])
+        existing_classes = html_classes(@html_options)
+        if existing_classes.is_a?(Array)
+          extras.concat(existing_classes.compact)
+        elsif existing_classes.is_a?(String)
+          extras << existing_classes
+        end
 
         class_names(
           "descriptions",
           {
             bordered: @bordered,
-            "small": @size == :small,
-            "middle": @size == :middle,
-            "vertical": @layout == :vertical
+            small: @size == :small,
+            default: @size == :default,
+            vertical: vertical_layout?
           },
-          column_classes
+          extras
         )
       end
 
+      sig { returns(T::Array[String]) }
       def build_column_classes
-        base = []
+        base = T.let([], T::Array[String])
 
         case @column
         when Integer
@@ -144,38 +194,25 @@ module HakumiComponents
         base
       end
 
-      def wrapper_attributes
-        merge_attributes({ class: wrapper_classes }, @html_options)
-      end
-
-      def table_classes
-        "hakumi-descriptions-view"
-      end
-
+      sig { returns(String) }
       def label_cell_classes
-        classes = [ "hakumi-descriptions-item-label" ]
-        classes << "hakumi-descriptions-item-label-colon" if @colon && @layout == :horizontal
-        classes.join(" ")
+        class_names("descriptions-item-label", { colon: @colon && !vertical_layout? })
       end
 
+      sig { returns(String) }
       def content_cell_classes
         "hakumi-descriptions-item-content"
       end
 
-      def render_title
-        return nil unless @title
-
-        content_tag(:div, class: "hakumi-descriptions-title") do
-          @title
-        end
-      end
-
-      def render_extra
-        return nil unless @extra
+      sig { params(column: T.any(Integer, T::Hash[Symbol, Integer])).returns(T.any(Integer, T::Hash[Symbol, Integer])) }
+      def normalize_column(column)
+        return column if column.is_a?(Integer)
 
-        content_tag(:div, class: "hakumi-descriptions-extra") do
-          @extra
+        normalized = T.let({}, T::Hash[Symbol, Integer])
+        column.each do |key, value|
+          normalized[key.to_sym] = value
         end
+        normalized
       end
     end
   end

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

@@ -1,12 +1,31 @@
+# typed: strict
 # frozen_string_literal: true
 
 module HakumiComponents
   module Descriptions
     module Item
       class Component < HakumiComponents::BaseComponent
-        attr_accessor :content
-        attr_reader :label, :span, :label_style, :content_style
+        extend T::Sig
 
+        sig { returns(Types::Renderable) }
+        attr_reader :label, :content
+
+        sig { returns(Integer) }
+        attr_reader :span
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :label_style, :content_style
+
+        sig do
+          params(
+            label: Types::Renderable,
+            content: Types::Renderable,
+            span: Integer,
+            label_style: T.nilable(String),
+            content_style: T.nilable(String),
+            html_options: Types::HtmlAttributeValue
+          ).void
+        end
         def initialize(
           label:,
           content: nil,
@@ -15,12 +34,17 @@ module HakumiComponents
           content_style: nil,
           **html_options
         )
-          @label = label
-          @content = content
-          @span = span
-          @label_style = label_style
-          @content_style = content_style
-          @html_options = html_options
+          @label = T.let(label, Types::Renderable)
+          @content = T.let(content, Types::Renderable)
+          @span = T.let(span, Integer)
+          @label_style = T.let(label_style, T.nilable(String))
+          @content_style = T.let(content_style, T.nilable(String))
+          @html_options = T.let(html_options, Types::HtmlAttributes)
+        end
+
+        sig { params(value: Types::Renderable).returns(Types::Renderable) }
+        def content=(value)
+          @content = value
         end
       end
     end

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

@@ -1,11 +1,23 @@
+# typed: strict
 # frozen_string_literal: true
 
 module HakumiComponents
   module Divider
     class Component < HakumiComponents::BaseComponent
-      ORIENTATIONS = [ :horizontal, :vertical ].freeze
-      PLACEMENTS = [ :left, :center, :right ].freeze
+      extend T::Sig
 
+      ORIENTATIONS = T.let([ :horizontal, :vertical ].freeze, T::Array[Symbol])
+      PLACEMENTS = T.let([ :left, :center, :right ].freeze, T::Array[Symbol])
+
+      sig do
+        params(
+          orientation: Symbol,
+          dashed: T::Boolean,
+          plain: T::Boolean,
+          orientation_margin: T.nilable(Symbol),
+          html_options: HakumiComponents::Types::HtmlAttributeValue
+        ).void
+      end
       def initialize(
         orientation: :horizontal,
         dashed: false,
@@ -13,15 +25,16 @@ module HakumiComponents
         orientation_margin: nil,
         **html_options
       )
-        @orientation = orientation
-        @dashed = dashed
-        @plain = plain
-        @orientation_margin = orientation_margin
-        @html_options = html_options
+        @orientation = T.let(orientation, Symbol)
+        @dashed = T.let(dashed, T::Boolean)
+        @plain = T.let(plain, T::Boolean)
+        @orientation_margin = T.let(orientation_margin, T.nilable(Symbol))
+        @html_options = T.let(html_options, HakumiComponents::Types::HtmlAttributes)
 
         validate_props!
       end
 
+      sig { returns(ActiveSupport::SafeBuffer) }
       def call
         if @orientation == :vertical
           content_tag(:span, nil, wrapper_attributes)
@@ -32,30 +45,37 @@ module HakumiComponents
 
       private
 
+      sig { void }
       def validate_props!
         validate_inclusion!(:orientation, ORIENTATIONS)
         validate_inclusion!(:orientation_margin, PLACEMENTS) if @orientation_margin
       end
 
+      sig { returns(String) }
       def wrapper_classes
-        classes = [ "hakumi-divider", "hakumi-divider-#{@orientation}" ]
-        classes << "hakumi-divider-dashed" if @dashed
-        classes << "hakumi-divider-with-text" if content.present?
-        classes << "hakumi-divider-plain" if @plain && content.present?
-        classes << "hakumi-divider-with-text-#{@orientation_margin}" if content.present? && @orientation_margin
-        classes << @html_options[:class] if @html_options[:class]
-        classes.join(" ")
+        with_text = @orientation == :horizontal && content.present?
+        modifiers = {
+          @orientation => true,
+          dashed: @dashed,
+          "with-text": with_text,
+          plain: @plain && with_text
+        }
+        modifiers[:"with-text-#{@orientation_margin}"] = true if with_text && @orientation_margin
+
+        class_names("divider", modifiers, html_classes(@html_options))
       end
 
+      sig { returns(HakumiComponents::Types::HtmlAttributes) }
       def wrapper_attributes
-        attrs = {
+        attrs = T.let({
           class: wrapper_classes,
           role: "separator"
-        }
+        }, HakumiComponents::Types::HtmlAttributes)
 
         merge_attributes(attrs, @html_options.except(:class))
       end
 
+      sig { returns(T.nilable(ActiveSupport::SafeBuffer)) }
       def content_wrapper
         return nil if content.blank?
 

data/app/components/hakumi_components/drawer/component.html.erb

@@ -23,8 +23,8 @@
                   </span>
                 </button>
               <% end %>
-              <% if header? %>
-                <div class="hakumi-drawer-title"><%= header %></div>
+              <% if header_content.present? %>
+                <div class="hakumi-drawer-title"><%= header_content %></div>
               <% end %>
             </div>
             <% if extra? %>

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

@@ -1,21 +1,68 @@
+# typed: strict
 # frozen_string_literal: true
 
 module HakumiComponents
   module Drawer
-    class Component < HakumiComponents::BaseComponent
-      PLACEMENTS = %i[left right top bottom].freeze
-      SIZES = {
+      class Component < HakumiComponents::BaseComponent
+        extend T::Sig
+
+      Placement = T.type_alias { Types::HtmlKey }
+      Size = T.type_alias { T.any(Integer, Types::HtmlKey) }
+      ResolvedSize = T.type_alias { T.any(Symbol, Integer) }
+
+      PLACEMENTS = T.let(%i[left right top bottom].freeze, T::Array[Symbol])
+      SIZES = T.let({
         default: 378,
         large: 736
-      }.freeze
+      }.freeze, T::Hash[Symbol, Integer])
 
-      # Slots for content
       renders_one :header
       renders_one :body
       renders_one :footer
       renders_one :extra
 
+      sig do
+        params(
+          params: BaseComponent::ControllerOptions
+        ).returns(HakumiComponents::Types::HtmlAttributes)
+      end
+      def self.extract_controller_locals(params)
+        {
+          open: boolean_html_param(html_param(params, :open)),
+          placement: symbol_html_param(html_param(params, :placement)),
+          size: size_param(html_param(params, :size)),
+          width: integer_html_param(html_param(params, :width)),
+          height: integer_html_param(html_param(params, :height)),
+          closable: boolean_html_param(html_param(params, :closable) || true),
+          mask: boolean_html_param(html_param(params, :mask) || true),
+          mask_closable: boolean_html_param(html_param(params, :mask_closable) || true),
+          keyboard: boolean_html_param(html_param(params, :keyboard) || true),
+          destroy_on_close: boolean_html_param(html_param(params, :destroy_on_close)),
+          title: html_primitive_param(html_param(params, :title)),
+          message: html_primitive_param(html_param(params, :message))
+        }.compact
+      end
+
+      sig do
+        params(
+          title: HakumiComponents::Types::Renderable,
+          message: HakumiComponents::Types::Renderable,
+          open: T::Boolean,
+          placement: Placement,
+          size: Size,
+          width: T.nilable(Integer),
+          height: T.nilable(Integer),
+          closable: T::Boolean,
+          mask: T::Boolean,
+          mask_closable: T::Boolean,
+          keyboard: T::Boolean,
+          destroy_on_close: T::Boolean,
+          html_options: HakumiComponents::Types::HtmlAttributeValue
+        ).void
+      end
       def initialize(
+        title: nil,
+        message: nil,
         open: false,
         placement: :right,
         size: :default,
@@ -26,49 +73,56 @@ module HakumiComponents
         mask_closable: true,
         keyboard: true,
         destroy_on_close: false,
-        **html_attributes
+        **html_options
       )
-        @open = open
-        @placement = placement
-        @size = size
-        @width = width
-        @height = height
-        @closable = closable
-        @mask = mask
-        @mask_closable = mask_closable
-        @keyboard = keyboard
-        @destroy_on_close = destroy_on_close
-        @html_attributes = html_attributes
+        @title = T.let(title, HakumiComponents::Types::Renderable)
+        @message = T.let(message, HakumiComponents::Types::Renderable)
+        @open = T.let(open, T::Boolean)
+        @placement = T.let(placement.to_sym, Symbol)
+        @size = T.let(size.is_a?(String) ? size.to_sym : size, ResolvedSize)
+        @width = T.let(width, T.nilable(Integer))
+        @height = T.let(height, T.nilable(Integer))
+        @closable = T.let(closable, T::Boolean)
+        @mask = T.let(mask, T::Boolean)
+        @mask_closable = T.let(mask_closable, T::Boolean)
+        @keyboard = T.let(keyboard, T::Boolean)
+        @destroy_on_close = T.let(destroy_on_close, T::Boolean)
+        @html_options = T.let(html_options, HakumiComponents::Types::HtmlAttributes)
 
         validate_props!
       end
 
+      sig { returns(String) }
       def drawer_classes
-        classes = [ "hakumi-drawer", "hakumi-drawer-#{@placement}" ]
-        classes << "hakumi-drawer-open" if @open
-        classes.join(" ")
+        class_names("drawer", { @placement => true, open: @open })
       end
 
+      sig { returns(HakumiComponents::Types::HtmlAttributes) }
       def root_attributes
         base_attrs = {
           class: drawer_classes,
           data: data_attributes
         }
 
-        merge_attributes(base_attrs, @html_attributes)
+        merge_attributes(base_attrs, @html_options)
       end
 
+      sig { returns(HakumiComponents::Types::DataAttributes) }
       def data_attributes
-        {
+        data = T.let({
           controller: "hakumi--drawer",
           hakumi__drawer_open_value: @open,
           hakumi__drawer_placement_value: @placement.to_s,
           hakumi__drawer_mask_closable_value: @mask_closable,
           hakumi__drawer_keyboard_value: @keyboard,
           hakumi__drawer_destroy_on_close_value: @destroy_on_close
-        }.merge(@html_attributes[:data] || {})
+        }, HakumiComponents::Types::DataAttributes)
+        existing = @html_options[:data]
+        existing.each { |key, value| data[key] = value } if existing.is_a?(Hash)
+        data
       end
 
+      sig { returns(String) }
       def wrapper_style
         size_value = resolve_size
         if %i[left right].include?(@placement)
@@ -78,31 +132,60 @@ module HakumiComponents
         end
       end
 
+      sig { returns(T::Boolean) }
       def render_header?
-        header? || @closable || extra?
+        header? || value_present?(@title) || @closable || extra?
       end
 
+      sig { returns(T::Boolean) }
       def render_footer?
         footer?
       end
 
-      # Content resolution: body slot > block content
+      sig { returns(HakumiComponents::Types::Renderable) }
       def body_content
-        body? ? body : content
+        return render_value(body) if body?
+        return render_value(content) if content.present?
+
+        render_value(@message)
+      end
+
+      sig { returns(HakumiComponents::Types::Renderable) }
+      def header_content
+        return render_value(header) if header?
+
+        render_value(@title)
       end
 
       private
 
+      class << self
+        extend T::Sig
+
+        private
+
+        sig { params(value: HakumiComponents::Types::HtmlAttributeValue).returns(T.nilable(ResolvedSize)) }
+        def size_param(value)
+          return value if value.is_a?(Integer)
+          return symbol_html_param(value) if value.is_a?(String) || value.is_a?(Symbol)
+
+          nil
+        end
+      end
+
+      sig { returns(Integer) }
       def resolve_size
-        return @size if @size.is_a?(Numeric) || @size.is_a?(String)
+        return @size if @size.is_a?(Integer)
 
-        SIZES.fetch(@size, SIZES[:default])
+        value = SIZES[@size]
+        value.nil? ? SIZES.fetch(:default) : value
       end
 
+      sig { void }
       def validate_props!
         validate_inclusion!(:placement, PLACEMENTS)
         validate_inclusion!(:size, SIZES.keys) if @size.is_a?(Symbol)
       end
-    end
+      end
   end
 end