hakumi_components 0.1.18.pre → 0.1.19.pre

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

@@ -1,45 +1,68 @@
+# typed: strict
 # frozen_string_literal: true
 
 module HakumiComponents
   module Menu
     module Item
       class Component < HakumiComponents::BaseComponent
+        extend T::Sig
+
+        sig do
+          params(
+            key: String,
+            label: T.nilable(String),
+            icon: T.nilable(T.any(Symbol, ViewComponent::Base)),
+            disabled: T::Boolean,
+            danger: T::Boolean,
+            href: T.nilable(String),
+            target: T.nilable(String),
+            html_options: Types::HtmlAttributeValue
+          ).void
+        end
         def initialize(key:, label: nil, icon: nil, disabled: false, danger: false, href: nil, target: nil, **html_options)
-          @key = key
-          @label = label
-          @icon = icon
-          @disabled = disabled
-          @danger = danger
-          @href = href
-          @target = target
-          @html_options = html_options
+          @key = T.let(key, String)
+          @label = T.let(label, T.nilable(String))
+          @icon = T.let(icon, T.nilable(T.any(Symbol, ViewComponent::Base)))
+          @disabled = T.let(disabled, T::Boolean)
+          @danger = T.let(danger, T::Boolean)
+          @href = T.let(href, T.nilable(String))
+          @target = T.let(target, T.nilable(String))
+          @html_options = T.let(html_options, Types::HtmlAttributes)
         end
 
-        attr_reader :key, :label, :icon, :disabled, :danger, :href, :target
+        sig { returns(String) }
+        attr_reader :key
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :label, :href, :target
+
+        sig { returns(T.nilable(T.any(Symbol, ViewComponent::Base))) }
+        attr_reader :icon
+
+        sig { returns(T::Boolean) }
+        attr_reader :disabled, :danger
 
+        sig { returns(String) }
         def item_classes
-          classes = [ "hakumi-menu-item" ]
-          classes << "hakumi-menu-item-disabled" if disabled
-          classes << "hakumi-menu-item-danger" if danger
-          classes.join(" ")
+          class_names("menu-item", { disabled: disabled, danger: danger })
         end
 
+        sig { returns(T::Boolean) }
         def link?
           href.present?
         end
 
+        sig { returns(Types::RenderedContent) }
         def display_label
           content.presence || label
         end
 
+        sig { returns(T.nilable(ViewComponent::Base)) }
         def icon_component
-          return nil unless icon
+          ic = @icon
+          return nil if ic.nil?
 
-          if icon.is_a?(Symbol)
-            HakumiComponents::Icon::Component.new(name: icon)
-          else
-            icon
-          end
+          ic.is_a?(Symbol) ? HakumiComponents::Icon::Component.new(name: ic) : ic
         end
       end
     end

data/app/components/hakumi_components/menu/sub_menu/component.rb

@@ -1,44 +1,32 @@
+# typed: strict
 # frozen_string_literal: true
 
 module HakumiComponents
   module Menu
     module SubMenu
       class Component < HakumiComponents::BaseComponent
+        extend T::Sig
+
         renders_many :items, types: {
           item: {
-            renders: ->(key:, label: nil, icon: nil, disabled: false, danger: false, href: nil, target: nil, **options, &block) do
-              HakumiComponents::Menu::Item::Component.new(
-                key: key,
-                label: label,
-                icon: icon,
-                disabled: disabled,
-                danger: danger,
-                href: href,
-                target: target,
-                **options,
-                &block
-              )
-            end,
+            renders: HakumiComponents::Menu::Item::Component,
             as: :item
           },
           submenu: {
-            renders: ->(key:, label: nil, icon: nil, disabled: false, **options, &block) do
+            renders: ->(key:, label: nil, icon: nil, disabled: false) do
+              T.bind(self, HakumiComponents::Menu::SubMenu::Component)
               HakumiComponents::Menu::SubMenu::Component.new(
                 key: key,
                 label: label,
                 icon: icon,
                 disabled: disabled,
-                mode: @mode,
-                **options,
-                &block
+                mode: mode
               )
             end,
             as: :submenu
           },
           group: {
-            renders: ->(label:, **options, &block) do
-              HakumiComponents::Menu::Group::Component.new(label: label, **options, &block)
-            end,
+            renders: HakumiComponents::Menu::Group::Component,
             as: :group
           },
           divider: {
@@ -47,44 +35,68 @@ module HakumiComponents
           }
         }
 
+        sig do
+          params(
+            key: String,
+            label: T.nilable(String),
+            icon: T.nilable(T.any(Symbol, ViewComponent::Base)),
+            disabled: T::Boolean,
+            mode: Symbol,
+            html_options: Types::HtmlAttributeValue
+          ).void
+        end
         def initialize(key:, label: nil, icon: nil, disabled: false, mode: :vertical, **html_options)
-          @key = key
-          @label = label
-          @icon = icon
-          @disabled = disabled
-          @mode = mode
-          @html_options = html_options
+          @key = T.let(key, String)
+          @label = T.let(label, T.nilable(String))
+          @icon = T.let(icon, T.nilable(T.any(Symbol, ViewComponent::Base)))
+          @disabled = T.let(disabled, T::Boolean)
+          @mode = T.let(mode, Symbol)
+          @html_options = T.let(html_options, Types::HtmlAttributes)
         end
 
-        attr_reader :key, :label, :icon, :disabled, :mode
+        sig { returns(String) }
+        attr_reader :key
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :label
+
+        sig { returns(T.nilable(T.any(Symbol, ViewComponent::Base))) }
+        attr_reader :icon
+
+        sig { returns(T::Boolean) }
+        attr_reader :disabled
+
+        sig { returns(Symbol) }
+        attr_reader :mode
 
+        sig { returns(String) }
         def submenu_classes
-          classes = [ "hakumi-menu-submenu" ]
-          classes << "hakumi-menu-submenu-#{popup? ? 'popup' : 'inline'}"
-          classes << "hakumi-menu-submenu-disabled" if disabled
-          classes.join(" ")
+          modifiers = T.let({ disabled: disabled }, Types::ClassModifiers)
+          modifiers[popup? ? :popup : :inline] = true
+          class_names("menu-submenu", modifiers)
         end
 
+        sig { returns(String) }
         def title_classes
           "hakumi-menu-submenu-title"
         end
 
+        sig { returns(T::Boolean) }
         def popup?
           mode != :inline
         end
 
+        sig { returns(Types::RenderedContent) }
         def display_label
           content.presence || label
         end
 
+        sig { returns(T.nilable(ViewComponent::Base)) }
         def icon_component
-          return nil unless icon
+          ic = @icon
+          return nil if ic.nil?
 
-          if icon.is_a?(Symbol)
-            HakumiComponents::Icon::Component.new(name: icon)
-          else
-            icon
-          end
+          ic.is_a?(Symbol) ? HakumiComponents::Icon::Component.new(name: ic) : ic
         end
       end
     end

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

@@ -1,50 +1,74 @@
+# typed: strict
 # frozen_string_literal: true
 
 module HakumiComponents
   module Message
     class Component < HakumiComponents::BaseComponent
-      TYPES = %i[success info warning error loading].freeze
+      extend T::Sig
 
-      # Extracts locals from controller params for dynamic rendering
-      # @param params [ActionController::Parameters]
-      # @return [Hash] Arguments for initialize
+      Type = T.type_alias { T.any(Symbol, String) }
+      TYPES = T.let(%i[success info warning error loading].freeze, T::Array[Symbol])
+
+      sig do
+        params(
+          params: T.any(ActionController::Parameters, HakumiComponents::Types::HtmlAttributes)
+        ).returns(HakumiComponents::Types::HtmlAttributes)
+      end
       def self.extract_controller_locals(params)
         {
-          message: params[:message].presence || "Generated message content.",
-          type: params[:type]&.to_sym,
-          duration: params[:duration]&.to_f,
-          key: params[:key],
-          icon: params[:icon],
-          closable: ActiveModel::Type::Boolean.new.cast(params[:closable]),
-          max_count: params[:max_count]&.to_i,
-          top: params[:top]&.to_i
+          message: html_primitive_param(html_param(params, :message)) || "Generated message content.",
+          type: symbol_html_param(html_param(params, :type)),
+          duration: float_html_param(html_param(params, :duration)),
+          key: html_primitive_param(html_param(params, :key)),
+          icon: html_primitive_param(html_param(params, :icon)),
+          closable: boolean_html_param(html_param(params, :closable)),
+          max_count: integer_html_param(html_param(params, :max_count)),
+          top: integer_html_param(html_param(params, :top))
         }
       end
 
+      sig do
+        params(
+          message: HakumiComponents::Types::HtmlPrimitive,
+          type: T.nilable(Type),
+          duration: T.nilable(Numeric),
+          key: HakumiComponents::Types::HtmlPrimitive,
+          icon: HakumiComponents::Types::HtmlPrimitive,
+          closable: T::Boolean,
+          max_count: T.nilable(Integer),
+          top: T.nilable(Integer),
+          close_label: T.nilable(String),
+          html_options: HakumiComponents::Types::HtmlAttributeValue
+        ).void
+      end
       def initialize(
         message: nil,
         type: nil,
-        duration: 3,
+        duration: 3.0,
         key: nil,
         icon: nil,
         closable: false,
         max_count: nil,
         top: nil,
+        # i18n
+        close_label: nil,
         **html_options
       )
-        @message = message
-        @type = type
-        @duration = duration.nil? ? 3 : duration
-        @key = key
-        @icon = icon
-        @closable = closable
-        @max_count = max_count
-        @top = top
-        @html_options = html_options
+        @message = T.let(message, HakumiComponents::Types::HtmlPrimitive)
+        @type = T.let(type&.to_sym, T.nilable(Symbol))
+        @duration = T.let(duration.nil? ? 3.0 : duration.to_f, Float)
+        @key = T.let(key, HakumiComponents::Types::HtmlPrimitive)
+        @icon = T.let(icon, HakumiComponents::Types::HtmlPrimitive)
+        @closable = T.let(closable, T::Boolean)
+        @max_count = T.let(max_count, T.nilable(Integer))
+        @top = T.let(top, T.nilable(Integer))
+        @close_label = T.let(close_label, T.nilable(String))
+        @html_options = T.let(html_options, HakumiComponents::Types::HtmlAttributes)
 
         validate_props!
       end
 
+      sig { returns(HakumiComponents::Types::HtmlAttributes) }
       def root_attributes
         base_attrs = {
           class: wrapper_classes,
@@ -59,13 +83,15 @@ module HakumiComponents
         merge_attributes(base_attrs, @html_options)
       end
 
+      sig { returns(HakumiComponents::Types::DataAttributes) }
       def data_attributes
-        attrs = {
+        attrs = T.let({
           controller: "hakumi--message",
           hakumi__message_duration_value: @duration,
           hakumi__message_max_count_value: @max_count,
-          hakumi__message_top_value: @top
-        }
+          hakumi__message_top_value: @top,
+          hakumi__message_close_label_value: close_label_text
+        }, HakumiComponents::Types::DataAttributes)
 
         payload = initial_payload
         attrs[:hakumi__message_payload_value] = payload.to_json if payload.present?
@@ -73,18 +99,26 @@ module HakumiComponents
         attrs
       end
 
+      sig { returns(String) }
+      def close_label_text
+        @close_label || t_default(:close, default: "Close")
+      end
+
+      sig { returns(String) }
       def wrapper_classes
-        class_names("message", {}, [ @html_options[:class] ])
+        component_classes("message", {}, @html_options)
       end
 
+      sig { returns(T.nilable(String)) }
       def inline_style
-        styles = []
+        styles = T.let([], T::Array[String])
         styles << "--hakumi-message-top: #{@top}px" if @top
         styles.join("; ") if styles.any?
       end
 
       private
 
+      sig { returns(HakumiComponents::Types::StimulusValues) }
       def initial_payload
         payload = {
           message: @message,
@@ -98,6 +132,7 @@ module HakumiComponents
         payload.presence
       end
 
+      sig { void }
       def validate_props!
         validate_inclusion!(:type, TYPES)
       end

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

@@ -1,4 +1,4 @@
-<%= content_tag(:div, class: classes, style: style, data: data_attributes, **@html_attributes.except(:class, :style, :data)) do %>
+<%= content_tag(:div, class: wrapper_classes, style: wrapper_style, data: data_attributes, **@html_options.except(:class, :style, :data)) do %>
   <% if @mask %>
     <div class="hakumi-modal-mask" data-hakumi--modal-target="mask" data-action="click->hakumi--modal#handleMaskClick"></div>
   <% end %>
@@ -16,11 +16,11 @@
 
         <% if render_header? %>
           <div class="hakumi-modal-header">
-            <% if header? %>
-              <div class="hakumi-modal-title"><%= header %></div>
+            <% if header_content.present? %>
+              <div class="hakumi-modal-title"><%= header_content %></div>
             <% end %>
-            <% if extra? %>
-              <div class="hakumi-modal-extra"><%= extra %></div>
+            <% if extra_content.present? %>
+              <div class="hakumi-modal-extra"><%= extra_content %></div>
             <% end %>
           </div>
         <% end %>
@@ -31,7 +31,7 @@
 
         <% if render_footer? %>
           <div class="hakumi-modal-footer">
-            <%= footer %>
+            <%= footer_content %>
           </div>
         <% end %>
       </div>

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

@@ -1,33 +1,54 @@
+# typed: strict
 # frozen_string_literal: true
 
 module HakumiComponents
   module Modal
     class Component < HakumiComponents::BaseComponent
-      # Slots for content
+      extend T::Sig
+
       renders_one :header
       renders_one :body
       renders_one :footer
       renders_one :extra
 
-      # Extracts locals from controller params for programmatic rendering
-      # @param params [ActionController::Parameters]
-      # @return [Hash] Arguments for initialize
+      sig do
+        params(
+          params: T.any(ActionController::Parameters, HakumiComponents::Types::HtmlAttributes)
+        ).returns(HakumiComponents::Types::HtmlAttributes)
+      end
       def self.extract_controller_locals(params)
         {
-          title: params[:title],
-          message: params[:message],
-          open: ActiveModel::Type::Boolean.new.cast(params[:open]),
-          width: params[:width]&.to_i,
-          centered: ActiveModel::Type::Boolean.new.cast(params[:centered]),
-          closable: ActiveModel::Type::Boolean.new.cast(params[:closable]),
-          mask: ActiveModel::Type::Boolean.new.cast(params[:mask]),
-          mask_closable: ActiveModel::Type::Boolean.new.cast(params[:mask_closable]),
-          keyboard: ActiveModel::Type::Boolean.new.cast(params[:keyboard]),
-          confirm_loading: ActiveModel::Type::Boolean.new.cast(params[:confirm_loading])
+          title: html_primitive_param(html_param(params, :title)),
+          message: html_primitive_param(html_param(params, :message)),
+          open: boolean_html_param(html_param(params, :open)),
+          width: integer_html_param(html_param(params, :width)),
+          centered: boolean_html_param(html_param(params, :centered)),
+          closable: boolean_html_param(html_param(params, :closable)),
+          mask: boolean_html_param(html_param(params, :mask)),
+          mask_closable: boolean_html_param(html_param(params, :mask_closable)),
+          keyboard: boolean_html_param(html_param(params, :keyboard)),
+          confirm_loading: boolean_html_param(html_param(params, :confirm_loading))
         }
       end
 
+      sig do
+        params(
+          title: HakumiComponents::Types::Renderable,
+          message: HakumiComponents::Types::Renderable,
+          open: T::Boolean,
+          width: T.any(Integer, String),
+          centered: T::Boolean,
+          closable: T::Boolean,
+          mask: T::Boolean,
+          mask_closable: T::Boolean,
+          keyboard: T::Boolean,
+          confirm_loading: T::Boolean,
+          html_options: HakumiComponents::Types::HtmlAttributeValue
+        ).void
+      end
       def initialize(
+        title: nil,
+        message: nil,
         open: false,
         width: 520,
         centered: false,
@@ -36,63 +57,95 @@ module HakumiComponents
         mask_closable: true,
         keyboard: true,
         confirm_loading: false,
-        **html_attributes
+        **html_options
       )
-        @open = open
-        @width = width
-        @centered = centered
-        @closable = closable
-        @mask = mask
-        @mask_closable = mask_closable
-        @keyboard = keyboard
-        @confirm_loading = confirm_loading
-        @html_attributes = html_attributes
-        super()
+        @title = T.let(title, HakumiComponents::Types::Renderable)
+        @message = T.let(message, HakumiComponents::Types::Renderable)
+        @open = T.let(cast_boolean(open) ? true : false, T::Boolean)
+        @width = T.let(width, T.any(Integer, String))
+        @centered = T.let(cast_boolean(centered) ? true : false, T::Boolean)
+        @closable = T.let(cast_boolean(closable) != false, T::Boolean)
+        @mask = T.let(cast_boolean(mask) != false, T::Boolean)
+        @mask_closable = T.let(cast_boolean(mask_closable) != false, T::Boolean)
+        @keyboard = T.let(cast_boolean(keyboard) != false, T::Boolean)
+        @confirm_loading = T.let(cast_boolean(confirm_loading) ? true : false, T::Boolean)
+        @html_options = T.let(html_options, HakumiComponents::Types::HtmlAttributes)
       end
 
       private
 
-      def classes
-        base_classes = [ "hakumi-modal-root" ]
-        base_classes << @html_attributes[:class] if @html_attributes[:class]
-        base_classes.compact.join(" ")
+      sig { returns(String) }
+      def wrapper_classes
+        component_classes("modal-root", {}, @html_options)
       end
 
-      def style
-        @html_attributes[:style]
+      sig { returns(T.nilable(String)) }
+      def wrapper_style
+        html_style(@html_options)
       end
 
+      sig { returns(HakumiComponents::Types::DataAttributes) }
       def data_attributes
-        {
+        defaults = T.let({
           controller: "hakumi--modal",
           hakumi__modal_open_value: @open,
           hakumi__modal_mask_closable_value: @mask_closable,
           hakumi__modal_keyboard_value: @keyboard,
           hakumi__modal_confirm_loading_value: @confirm_loading
-        }.merge(@html_attributes[:data] || {})
+        }, HakumiComponents::Types::DataAttributes)
+        extra = @html_options[:data]
+        return defaults unless extra.is_a?(Hash)
+
+        defaults.merge(extra)
       end
 
+      sig { returns(String) }
       def modal_classes
-        classes = [ "hakumi-modal" ]
-        classes << "hakumi-modal-centered" if @centered
-        classes.join(" ")
+        class_names("modal", { centered: @centered })
       end
 
+      sig { returns(String) }
       def modal_style
-        "width: #{@width}px;"
+        "width: #{dimension_to_css(@width)};"
       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 header_content
+        return render_value(header) if header?
+
+        render_value(@title)
+      end
+
+      sig { returns(HakumiComponents::Types::Renderable) }
+      def extra_content
+        return render_value(extra) if extra?
+
+        nil
+      end
+
+      sig { returns(HakumiComponents::Types::Renderable) }
+      def footer_content
+        return render_value(footer) if footer?
+
+        nil
+      end
+
+      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
     end
   end

data/app/components/hakumi_components/modal/confirm/component.html.erb

@@ -3,10 +3,10 @@
   open: @open,
   mask_closable: false,
   closable: false,
-  **@html_attributes
+  **@html_options
 ) do |modal| %>
   <% modal.with_header do %>
-    <%= @title %>
+    <%= render_value(resolved_title) %>
   <% end %>
 
   <div class="hakumi-modal-confirm-body-wrapper">