hakumi_components 0.1.18.pre → 0.1.19.pre

data/app/components/hakumi_components/mentions/coercion.rb

@@ -0,0 +1,46 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Mentions
+    module Coercion
+      extend T::Sig
+      extend self
+
+      OptionHash = T.type_alias do
+        T::Hash[T.any(Symbol, String), T.nilable(T.any(String, Symbol, Numeric))]
+      end
+      OptionTuple = T.type_alias { [ T.nilable(T.any(String, Symbol, Numeric)), T.nilable(T.any(String, Symbol, Numeric)) ] }
+      OptionInput = T.type_alias { T.any(HakumiComponents::Mentions::Option, OptionHash, OptionTuple, String, Symbol, Numeric) }
+
+      sig { params(options: T::Array[OptionInput]).returns(T::Array[HakumiComponents::Mentions::Option]) }
+      def options(options)
+        options.filter_map { |option| normalize_option(option) }
+      end
+
+      private
+
+      sig { params(option: OptionInput).returns(T.nilable(HakumiComponents::Mentions::Option)) }
+      def normalize_option(option)
+        return option if option.is_a?(HakumiComponents::Mentions::Option)
+
+        case option
+        when Hash
+          label = option[:label] || option["label"]
+          value = option[:value] || option["value"] || label
+          return nil if label.nil?
+
+          HakumiComponents::Mentions::Option.new(label: label.to_s, value: value.to_s)
+        when Array
+          label = option[0]
+          value = option[1] || label
+          return nil if label.nil?
+
+          HakumiComponents::Mentions::Option.new(label: label.to_s, value: value.to_s)
+        else
+          HakumiComponents::Mentions::Option.new(label: option.to_s, value: option.to_s)
+        end
+      end
+    end
+  end
+end

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

@@ -1,9 +1,9 @@
 <% mentions_control = capture do %>
   <div <%= tag.attributes(wrapper_attributes).to_s.html_safe %>>
     <% if single_line? %>
-      <%= tag.input(type: :text, value: @value, **field_attributes) %>
+      <%= tag.input(type: :text, value: input_control_value, **field_attributes) %>
     <% else %>
-      <%= content_tag(:textarea, @value, **field_attributes) %>
+      <%= content_tag(:textarea, input_control_value, **field_attributes) %>
     <% end %>
 
     <div
@@ -14,11 +14,11 @@
         <button
           type="button"
           class="hakumi-mentions-option"
-          data-value="<%= option[:value] %>"
-          data-label="<%= option[:label] %>"
+          data-value="<%= option.value %>"
+          data-label="<%= option.label %>"
           data-action="mousedown->hakumi--mentions#select click->hakumi--mentions#select"
           data-hakumi--mentions-target="option">
-          <span class="hakumi-mentions-option-label"><%= option[:label] %></span>
+          <span class="hakumi-mentions-option-label"><%= option.label %></span>
         </button>
       <% end %>
 
@@ -32,7 +32,7 @@
   </div>
 <% end %>
 
-<% if @standalone %>
+<% if standalone? %>
   <%= mentions_control %>
 <% else %>
   <div <%= tag.attributes(form_item_attributes).to_s.html_safe %>>

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

@@ -1,16 +1,44 @@
+# typed: strict
 # frozen_string_literal: true
 
 module HakumiComponents
   module Mentions
-    # Hakumi Mentions component
-    # Textarea input with dropdown suggestions for mentions
     class Component < HakumiComponents::BaseComponent
-      include HakumiComponents::Concerns::FormField
-
-      SIZES = %i[small default large].freeze
-      STATUSES = [ nil, :error, :warning ].freeze
-      VARIANTS = %i[outlined borderless filled].freeze
-
+      extend T::Sig
+
+      include HakumiComponents::Concerns::InputControl
+
+      OptionInput = T.type_alias { HakumiComponents::Mentions::Coercion::OptionInput }
+      MentionPrefix = T.type_alias { T.any(Types::StringOrSymbol, Types::StringOrSymbolArray) }
+
+      STATUSES = T.let([ nil, :error, :warning ].freeze, T::Array[T.nilable(Symbol)])
+      VARIANTS = T.let(%i[outlined borderless filled].freeze, T::Array[Symbol])
+
+      sig do
+        params(
+          name: Types::FormFieldName,
+          label: T.nilable(String),
+          caption: T.nilable(String),
+          value: Types::FormFieldValue,
+          default_value: Types::FormFieldValue,
+          options: T::Array[OptionInput],
+          prefix: MentionPrefix,
+          split: String,
+          filter_option: T.nilable(Types::StringOrSymbol),
+          placeholder: T.nilable(String),
+          disabled: T::Boolean,
+          readonly: T::Boolean,
+          required: T::Boolean,
+          rows: T.nilable(Integer),
+          auto_size: T::Boolean,
+          size: Symbol,
+          variant: Symbol,
+          status: T.nilable(Symbol),
+          standalone: T::Boolean,
+          errors: Types::FormFieldErrors,
+          html_options: Types::HtmlAttributeValue
+        ).void
+      end
       def initialize(
         name:,
         label: nil,
@@ -34,13 +62,13 @@ module HakumiComponents
         errors: [],
         **html_options
       )
-        @name = name
+        @name = T.let(name, Types::FormFieldName)
         @label = label
         @caption = caption
-        @value = value.nil? ? default_value : value
-        @default_value = default_value
-        @options = options
-        @prefix = prefix
+        @value = T.let(value.nil? ? default_value : value, Types::FormFieldValue)
+        @default_value = T.let(default_value, Types::FormFieldValue)
+        @options = T.let(HakumiComponents::Mentions::Coercion.options(options), T::Array[HakumiComponents::Mentions::Option])
+        @prefix = T.let(prefix, MentionPrefix)
         @split = split
         @filter_option = filter_option
         @placeholder = placeholder
@@ -53,113 +81,149 @@ module HakumiComponents
         @variant = variant
         @status = status
         @standalone = standalone
-        @errors = Array(errors)
-        @html_options = html_options
+        @errors = T.let(errors, Types::FormFieldErrors)
+        @html_options = T.let(html_options, Types::HtmlAttributes)
+        initialize_input_control_contract!(
+          name: @name,
+          label: @label,
+          caption: @caption,
+          value: @value,
+          placeholder: @placeholder,
+          size: @size,
+          disabled: @disabled,
+          readonly: @readonly,
+          errors: @errors,
+          standalone: @standalone,
+          required: @required,
+          html_options: @html_options
+        )
+
+        validate_props!
+      end
 
+      private
+
+      sig { void }
+      def validate_props!
         validate_inclusion!(:size, SIZES)
         validate_inclusion!(:variant, VARIANTS)
         validate_inclusion!(:status, STATUSES) if @status
       end
 
-      private
-
+      sig { returns(T::Boolean) }
       def single_line?
         @rows.nil? || @rows == 1
       end
 
+      sig { returns(T::Boolean) }
       def multiline?
         !single_line?
       end
 
+      sig { returns(String) }
       def wrapper_classes
         class_names(
           "mentions",
           {
-            disabled: @disabled,
-            readonly: @readonly,
-            "single": single_line?,
-            "sm": single_line? && @size == :small,
-            "lg": single_line? && @size == :large,
+            disabled: input_control_disabled,
+            readonly: input_control_readonly,
+            single: single_line?,
+            sm: single_line? && input_control_size == :small,
+            lg: single_line? && input_control_size == :large,
             "variant-borderless": @variant == :borderless,
             "variant-filled": @variant == :filled,
-            "status-error": @status == :error || has_error?,
+            "status-error": @status == :error || error?,
             "status-warning": @status == :warning
           },
-          [ @html_options[:class] ]
+          [ html_class_name ]
         )
       end
 
+      sig { returns(Types::HtmlAttributes) }
       def wrapper_attributes
         base_attrs = {
           class: wrapper_classes,
           data: {
             controller: "hakumi--mentions",
-            hakumi__mentions_options_value: normalized_options.to_json,
-            hakumi__mentions_prefix_value: Array(@prefix).to_json,
-            hakumi__mentions_split_value: @split.to_s,
+            hakumi__mentions_options_value: normalized_options.map(&:to_h).to_json,
+            hakumi__mentions_prefix_value: prefix_values.to_json,
+            hakumi__mentions_split_value: @split,
             hakumi__mentions_filter_option_value: filter_option_value,
-            hakumi__mentions_disabled_value: @disabled ? "true" : "false",
-            hakumi__mentions_readonly_value: @readonly ? "true" : "false",
-            hakumi__mentions_auto_size_value: @auto_size ? "true" : "false"
+            hakumi__mentions_disabled_value: input_control_disabled,
+            hakumi__mentions_readonly_value: input_control_readonly,
+            hakumi__mentions_auto_size_value: @auto_size
           }
         }
 
-        extra = @html_options.except(:class)
-        merge_attributes(base_attrs, extra)
+        merge_attributes(base_attrs, form_field_html_options.except(:class))
       end
 
+      sig { returns(Types::HtmlAttributes) }
       def field_attributes
-        base_attrs = {
-          name: @name,
+        attrs = T.let({
+          name: form_field_name,
           id: input_id,
           class: field_classes,
-          placeholder: @placeholder,
-          disabled: @disabled ? true : nil,
-          readonly: @readonly ? true : nil,
-          "aria-invalid": has_error? ? "true" : nil,
+          placeholder: input_control_placeholder,
+          disabled: input_control_disabled ? true : nil,
+          readonly: input_control_readonly ? true : nil,
+          "aria-invalid": error? ? "true" : nil,
           "aria-describedby": describedby_ids,
-          data: {
-            action: "input->hakumi--mentions#handleInput keydown->hakumi--mentions#handleKeydown focus->hakumi--mentions#handleFocus blur->hakumi--mentions#handleBlur",
-            "hakumi--mentions-target": single_line? ? "input" : "textarea"
-          }
-        }
-
-        # Add rows only for textarea (multiline)
-        base_attrs[:rows] = @rows || 3 if multiline?
+          data: field_data_attributes
+        }.compact, Types::HtmlAttributes)
 
-        # Add scroll handler only for textarea
-        if multiline?
-          base_attrs[:data][:action] += " scroll->hakumi--mentions#handleScroll"
-        end
-
-        base_attrs.compact
+        attrs[:rows] = effective_rows if multiline?
+        attrs
       end
 
+      sig { returns(String) }
       def field_classes
         "hakumi-mentions-input hakumi-input"
       end
 
+      sig { returns(T::Array[HakumiComponents::Mentions::Option]) }
       def normalized_options
-        Array(@options).filter_map do |opt|
-          case opt
-          when nil
-            nil
-          when Hash
-            label = opt[:label] || opt["label"]
-            value = opt[:value] || opt["value"] || label
-            { label: label.to_s, value: value.to_s }
-          when Array
-            label, value = opt
-            { label: label.to_s, value: (value || label).to_s }
-          else
-            { label: opt.to_s, value: opt.to_s }
-          end
-        end
+        @options
       end
 
+      sig { returns(String) }
       def filter_option_value
         @filter_option.nil? ? "contains" : @filter_option.to_s
       end
+
+      sig { returns(T::Array[String]) }
+      def prefix_values
+        values = @prefix.is_a?(Array) ? @prefix : [ @prefix ]
+        values.map(&:to_s)
+      end
+
+      sig { returns(Types::DataAttributes) }
+      def field_data_attributes
+        action = T.let([
+          "input->hakumi--mentions#handleInput",
+          "keydown->hakumi--mentions#handleKeydown",
+          "focus->hakumi--mentions#handleFocus",
+          "blur->hakumi--mentions#handleBlur"
+        ], T::Array[String])
+        action << "scroll->hakumi--mentions#handleScroll" if multiline?
+
+        {
+          action: action.join(" "),
+          "hakumi--mentions-target": single_line? ? "input" : "textarea"
+        }
+      end
+
+      sig { returns(Integer) }
+      def effective_rows
+        rows = @rows
+        rows.nil? ? 3 : rows
+      end
+
+      sig { returns(T.nilable(String)) }
+      def html_class_name
+        css_class = form_field_html_options[:class]
+        css_class.is_a?(String) ? css_class : nil
+      end
     end
   end
 end

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

@@ -0,0 +1,30 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Mentions
+    class Option
+      extend T::Sig
+
+      sig { params(label: String, value: String).void }
+      def initialize(label:, value:)
+        @label = label
+        @value = value
+      end
+
+      sig { returns(String) }
+      attr_reader :label
+
+      sig { returns(String) }
+      attr_reader :value
+
+      sig { returns(T::Hash[Symbol, String]) }
+      def to_h
+        {
+          label: @label,
+          value: @value
+        }
+      end
+    end
+  end
+end

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

@@ -1,46 +1,34 @@
+# typed: strict
 # frozen_string_literal: true
 
 module HakumiComponents
   module Menu
     class Component < HakumiComponents::BaseComponent
-      MODES = %i[horizontal vertical inline].freeze
-      TRIGGER_SUBMENU_ACTIONS = %i[hover click].freeze
+      extend T::Sig
+
+      MODES = T.let(%i[horizontal vertical inline].freeze, T::Array[Symbol])
+      TRIGGER_SUBMENU_ACTIONS = T.let(%i[hover click].freeze, T::Array[Symbol])
 
       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::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: {
@@ -49,6 +37,19 @@ module HakumiComponents
         }
       }
 
+      sig do
+        params(
+          mode: Symbol,
+          selectable: T::Boolean,
+          multiple: T::Boolean,
+          inline_collapsed: T::Boolean,
+          inline_indent: Integer,
+          default_selected_keys: Types::StringOrSymbolArray,
+          default_open_keys: Types::StringOrSymbolArray,
+          trigger_submenu_action: Symbol,
+          html_options: Types::HtmlAttributeValue
+        ).void
+      end
       def initialize(
         mode: :vertical,
         selectable: true,
@@ -60,35 +61,38 @@ module HakumiComponents
         trigger_submenu_action: :hover,
         **html_options
       )
-        @mode = mode
-        @selectable = selectable
-        @multiple = multiple
-        @inline_collapsed = inline_collapsed
-        @inline_indent = inline_indent
-        @default_selected_keys = Array(default_selected_keys)
-        @default_open_keys = Array(default_open_keys)
-        @trigger_submenu_action = trigger_submenu_action
-        @html_options = html_options
+        @mode = T.let(mode, Symbol)
+        @selectable = T.let(selectable, T::Boolean)
+        @multiple = T.let(multiple, T::Boolean)
+        @inline_collapsed = T.let(inline_collapsed, T::Boolean)
+        @inline_indent = T.let(inline_indent, Integer)
+        @default_selected_keys = T.let(Array(default_selected_keys), Types::StringOrSymbolArray)
+        @default_open_keys = T.let(Array(default_open_keys), Types::StringOrSymbolArray)
+        @trigger_submenu_action = T.let(trigger_submenu_action, Symbol)
+        @html_options = T.let(html_options, Types::HtmlAttributes)
 
         validate_props!
       end
 
-      attr_reader :mode, :inline_indent
+      sig { returns(Symbol) }
+      attr_reader :mode
 
-      def menu_classes
-        classes = [ "hakumi-menu" ]
-        classes << "hakumi-menu-root"
-        classes << "hakumi-menu-#{@mode}"
-        classes << "hakumi-menu-inline-collapsed" if @inline_collapsed && @mode == :inline
-        classes.join(" ")
-      end
+      sig { returns(Integer) }
+      attr_reader :inline_indent
 
-      def stimulus_controller
-        "hakumi--menu"
+      sig { returns(String) }
+      def menu_classes
+        modifiers = T.let({
+          root: true,
+          @mode => true,
+          "inline-collapsed": @inline_collapsed && @mode == :inline
+        }, Types::ClassModifiers)
+        class_names("menu", modifiers)
       end
 
-      def stimulus_values
-        {
+      sig { returns(Types::HtmlAttributes) }
+      def wrapper_attributes
+        data = stimulus_attrs("hakumi--menu", T.let({
           mode: @mode.to_s,
           selectable: @selectable,
           multiple: @multiple,
@@ -97,26 +101,13 @@ module HakumiComponents
           default_selected_keys: @default_selected_keys.to_json,
           default_open_keys: @default_open_keys.to_json,
           trigger_submenu_action: @trigger_submenu_action.to_s
-        }
-      end
-
-      def wrapper_attributes
-        base_attrs = {
-          class: menu_classes,
-          role: "menu",
-          data: {
-            controller: stimulus_controller
-          }.merge(stimulus_data_attributes)
-        }
-        merge_attributes(base_attrs, @html_options)
+        }, Types::StimulusValues))
+        merge_attributes({ class: menu_classes, role: "menu", data: data }, @html_options)
       end
 
       private
 
-      def stimulus_data_attributes
-        stimulus_values.transform_keys { |k| "#{stimulus_controller}-#{k.to_s.dasherize}-value" }
-      end
-
+      sig { void }
       def validate_props!
         validate_inclusion!(:mode, MODES)
         validate_inclusion!(:trigger_submenu_action, TRIGGER_SUBMENU_ACTIONS)

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

@@ -1,9 +1,13 @@
+# typed: strict
 # frozen_string_literal: true
 
 module HakumiComponents
   module Menu
     module Divider
       class Component < HakumiComponents::BaseComponent
+        extend T::Sig
+
+        sig { returns(ActiveSupport::SafeBuffer) }
         def call
           tag.li(class: "hakumi-menu-item-divider", role: "separator")
         end

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

@@ -1,43 +1,44 @@
+# typed: strict
 # frozen_string_literal: true
 
 module HakumiComponents
   module Menu
     module Group
       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
           }
         }
 
+        sig do
+          params(
+            label: String,
+            html_options: Types::HtmlAttributeValue
+          ).void
+        end
         def initialize(label:, **html_options)
-          @label = label
-          @html_options = html_options
+          @label = T.let(label, String)
+          @html_options = T.let(html_options, Types::HtmlAttributes)
         end
 
+        sig { returns(String) }
         attr_reader :label
 
+        sig { returns(String) }
         def group_classes
           "hakumi-menu-item-group"
         end
 
+        sig { returns(String) }
         def title_classes
           "hakumi-menu-item-group-title"
         end
 
+        sig { returns(String) }
         def list_classes
           "hakumi-menu-item-group-list"
         end