hakumi_components 0.1.18.pre → 0.1.19.pre

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

@@ -1,14 +1,17 @@
+# typed: strict
 # frozen_string_literal: true
 
 module HakumiComponents
   module Steps
     class Component < HakumiComponents::BaseComponent
-      DIRECTIONS = %i[horizontal vertical].freeze
-      TYPES = %i[default navigation inline].freeze
-      SIZES = %i[default small].freeze
-      STATUSES = %i[wait process finish error].freeze
-      LABEL_PLACEMENTS = %i[horizontal vertical].freeze
-      VARIANTS = %i[filled outlined].freeze
+      extend T::Sig
+
+      DIRECTIONS = T.let(%i[horizontal vertical].freeze, T::Array[Symbol])
+      TYPES = T.let(%i[default navigation inline].freeze, T::Array[Symbol])
+      SIZES = T.let(%i[default small].freeze, T::Array[Symbol])
+      STATUSES = T.let(%i[wait process finish error].freeze, T::Array[Symbol])
+      LABEL_PLACEMENTS = T.let(%i[horizontal vertical].freeze, T::Array[Symbol])
+      VARIANTS = T.let(%i[filled outlined].freeze, T::Array[Symbol])
 
       renders_many :items, ->(
         title: nil,
@@ -35,6 +38,23 @@ module HakumiComponents
         )
       end
 
+      sig do
+        params(
+          current: Integer,
+          direction: Symbol,
+          type: Symbol,
+          size: Symbol,
+          status: Symbol,
+          label_placement: T.nilable(Symbol),
+          percent: T.nilable(Numeric),
+          progress_dot: T::Boolean,
+          responsive: T::Boolean,
+          initial: Integer,
+          clickable: T::Boolean,
+          variant: Symbol,
+          html_options: Types::HtmlAttributeValue
+        ).void
+      end
       def initialize(
         current: 0,
         direction: :horizontal,
@@ -50,71 +70,77 @@ module HakumiComponents
         variant: :filled,
         **html_options
       )
-        @current = current
-        @direction = direction
-        @type = type
-        @size = size
-        @status = status
-        @label_placement = label_placement
-        @percent = percent
-        @progress_dot = progress_dot
-        @responsive = responsive
-        @initial = initial
-        @clickable = clickable
-        @variant = variant
-        @html_options = html_options
+        @current = T.let(current, Integer)
+        @direction = T.let(direction, Symbol)
+        @type = T.let(type, Symbol)
+        @size = T.let(size, Symbol)
+        @status = T.let(status, Symbol)
+        @label_placement = T.let(label_placement, T.nilable(Symbol))
+        @percent = T.let(percent, T.nilable(Numeric))
+        @progress_dot = T.let(progress_dot, T::Boolean)
+        @responsive = T.let(responsive, T::Boolean)
+        @initial = T.let(initial, Integer)
+        @clickable = T.let(clickable, T::Boolean)
+        @variant = T.let(variant, Symbol)
+        @html_options = T.let(html_options, Types::HtmlAttributes)
 
         validate_props!
       end
 
-      attr_reader :current, :direction, :type, :size, :status, :label_placement,
-                  :percent, :progress_dot, :responsive, :initial, :clickable, :variant
+      sig { returns(Integer) }
+      attr_reader :current, :initial
+
+      sig { returns(Symbol) }
+      attr_reader :direction, :type, :size, :status, :variant
+
+      sig { returns(T.nilable(Symbol)) }
+      attr_reader :label_placement
 
+      sig { returns(T.nilable(Numeric)) }
+      attr_reader :percent
+
+      sig { returns(T::Boolean) }
+      attr_reader :progress_dot, :responsive, :clickable
+
+      sig { returns(String) }
       def steps_classes
-        class_names(
-          "steps",
-          {
-            direction => true,
-            type => @type != :default,
-            small: @size == :small,
-            "label-#{effective_label_placement}" => @direction == :horizontal && @type == :default,
-            "with-progress" => @percent.present?,
-            dot: @progress_dot,
-            navigation: @type == :navigation,
-            inline: @type == :inline,
-            variant => @variant != :filled
-          },
-          [ @html_options[:class] ]
-        )
+        modifiers = T.let({
+          direction => true,
+          type => @type != :default,
+          small: @size == :small,
+          "label-#{effective_label_placement}": @direction == :horizontal && @type == :default,
+          "with-progress": @percent.present?,
+          dot: @progress_dot,
+          navigation: @type == :navigation,
+          inline: @type == :inline,
+          variant => @variant != :filled
+        }, Types::ClassModifiers)
+        component_classes("steps", modifiers, @html_options)
       end
 
+      sig { returns(Symbol) }
       def effective_label_placement
         return :vertical if @progress_dot && @direction == :horizontal
+
         @label_placement || :horizontal
       end
 
+      sig { returns(Types::HtmlAttributes) }
       def wrapper_attributes
-        base_attrs = {
-          class: steps_classes,
-          data: stimulus_data
-        }
-        merge_attributes(base_attrs, @html_options.except(:class))
-      end
-
-      def stimulus_controller
-        "hakumi--steps"
-      end
-
-      def stimulus_data
-        {
-          controller: stimulus_controller,
-          "#{stimulus_controller}-current-value" => @current,
-          "#{stimulus_controller}-clickable-value" => @clickable
-        }
+        data = stimulus_attrs("hakumi--steps", T.let({
+          current: @current,
+          clickable: @clickable
+        }, Types::StimulusValues))
+        merge_attributes({ class: steps_classes, data: data }, @html_options.except(:class))
       end
 
+      sig { params(index: Integer).returns(Symbol) }
       def item_status(index)
-        return items[index].status if items[index].status.present?
+        raw_item = items[index]
+        if raw_item && raw_item.respond_to?(:status)
+          s = raw_item.status
+          return s if s
+        end
 
         if index < @current
           :finish
@@ -125,13 +151,19 @@ module HakumiComponents
         end
       end
 
+      sig { params(index: Integer).returns(T::Boolean) }
       def item_clickable?(index)
         return false unless @clickable
-        !items[index].disabled
+
+        raw_item = items[index]
+        return false unless raw_item && raw_item.respond_to?(:disabled)
+
+        !raw_item.disabled
       end
 
       private
 
+      sig { void }
       def validate_props!
         validate_inclusion!(:direction, DIRECTIONS)
         validate_inclusion!(:type, TYPES)

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

@@ -1,11 +1,28 @@
+# typed: strict
 # frozen_string_literal: true
 
 module HakumiComponents
   module Steps
     module Item
       class Component < HakumiComponents::BaseComponent
-        STATUSES = %i[wait process finish error].freeze
+        extend T::Sig
 
+        STATUSES = T.let(%i[wait process finish error].freeze, T::Array[Symbol])
+
+        sig do
+          params(
+            title: T.nilable(Types::Renderable),
+            subtitle: T.nilable(String),
+            description: T.nilable(Types::Renderable),
+            tooltip: T.nilable(String),
+            icon: T.nilable(T.any(Symbol, ViewComponent::Base)),
+            icon_spin: T::Boolean,
+            status: T.nilable(Symbol),
+            disabled: T::Boolean,
+            parent: T.nilable(HakumiComponents::Steps::Component),
+            html_options: Types::HtmlAttributeValue
+          ).void
+        end
         def initialize(
           title: nil,
           subtitle: nil,
@@ -18,24 +35,38 @@ module HakumiComponents
           parent: nil,
           **html_options
         )
-          @title = title
-          @subtitle = subtitle
-          @description = description
-          @tooltip = tooltip
-          @icon = icon
-          @icon_spin = icon_spin
-          @status = status
-          @disabled = disabled
-          @parent = parent
-          @html_options = html_options
+          @title = T.let(title, T.nilable(Types::Renderable))
+          @subtitle = T.let(subtitle, T.nilable(String))
+          @description = T.let(description, T.nilable(Types::Renderable))
+          @tooltip = T.let(tooltip, T.nilable(String))
+          @icon = T.let(icon, T.nilable(T.any(Symbol, ViewComponent::Base)))
+          @icon_spin = T.let(icon_spin, T::Boolean)
+          @status = T.let(status, T.nilable(Symbol))
+          @disabled = T.let(disabled, T::Boolean)
+          @parent = T.let(parent, T.nilable(HakumiComponents::Steps::Component))
+          @html_options = T.let(html_options, Types::HtmlAttributes)
 
           validate_props!
         end
 
-        attr_reader :title, :subtitle, :description, :tooltip, :icon, :icon_spin, :status, :disabled
+        sig { returns(T.nilable(Types::Renderable)) }
+        attr_reader :title, :description
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :subtitle, :tooltip
+
+        sig { returns(T.nilable(T.any(Symbol, ViewComponent::Base))) }
+        attr_reader :icon
 
+        sig { returns(T::Boolean) }
+        attr_reader :icon_spin, :disabled
+
+        sig { returns(T.nilable(Symbol)) }
+        attr_reader :status
+
+        sig { params(computed_status: Symbol, clickable: T::Boolean).returns(String) }
         def item_classes(computed_status, clickable)
-          classes = [ "hakumi-steps-item" ]
+          classes = T.let([ "hakumi-steps-item" ], T::Array[String])
           classes << "hakumi-steps-item-#{computed_status}"
           classes << "hakumi-steps-item-disabled" if @disabled
           classes << "hakumi-steps-item-clickable" if clickable && !@disabled
@@ -43,21 +74,28 @@ module HakumiComponents
           classes.join(" ")
         end
 
+        sig { params(index: Integer, computed_status: Symbol, clickable: T::Boolean).returns(Types::HtmlAttributes) }
         def wrapper_attributes(index, computed_status, clickable)
-          base_attrs = {
-            class: item_classes(computed_status, clickable)
-          }
+          base_attrs = T.let({ class: item_classes(computed_status, clickable) }, Types::HtmlAttributes)
 
           if clickable && !@disabled
-            base_attrs[:data] = {
+            base_attrs[:data] = T.let({
               action: "click->hakumi--steps#selectStep",
               "step-index" => index
-            }
+            }, Types::DataAttributes)
           end
 
           merge_attributes(base_attrs, @html_options)
         end
 
+        sig do
+          params(
+            computed_status: Symbol,
+            index: Integer,
+            progress_dot: T::Boolean,
+            percent: T.nilable(Numeric)
+          ).returns(T.nilable(T.any(Symbol, ViewComponent::Base)))
+        end
         def icon_content(computed_status, index, progress_dot, percent)
           return nil if progress_dot
 
@@ -69,19 +107,20 @@ module HakumiComponents
               :check
             when :error
               :close
-            else
-              nil
             end
           end
         end
 
+        sig { params(computed_status: Symbol).returns(T::Boolean) }
         def show_number?(computed_status)
           return false if @icon
+
           %i[wait process].include?(computed_status)
         end
 
         private
 
+        sig { void }
         def validate_props!
           validate_inclusion!(:status, STATUSES) if @status
         end

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

@@ -1,7 +1,6 @@
 <% switch_control = capture do %>
-  <% # Rails convention: hidden field with value="0" ensures unchecked state sends params %>
-  <% if @name && !standalone? %>
-    <%= tag.input(type: "hidden", name: @name, value: "0", autocomplete: "off") %>
+  <% if form_field_name && !standalone? %>
+    <%= tag.input(type: "hidden", name: form_field_name, value: "0", autocomplete: "off") %>
   <% end %>
   <%= content_tag(:label, **wrapper_attributes) do %>
     <%= tag.input(**input_attributes) %>

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

@@ -1,12 +1,31 @@
+# typed: strict
 # frozen_string_literal: true
 
 module HakumiComponents
   module Switch
     class Component < HakumiComponents::BaseComponent
-      include HakumiComponents::Concerns::FormField
+      extend T::Sig
 
-      SIZES = [ :small, :middle, :large ].freeze
+      include HakumiComponents::Concerns::FormField
 
+      sig do
+        params(
+          name: T.nilable(Types::FormFieldName),
+          label: T.nilable(String),
+          caption: T.nilable(String),
+          checked: T.nilable(T::Boolean),
+          default_checked: T::Boolean,
+          disabled: T::Boolean,
+          loading: T::Boolean,
+          size: Symbol,
+          checked_text: Types::Renderable,
+          unchecked_text: Types::Renderable,
+          standalone: T::Boolean,
+          required: T::Boolean,
+          errors: Types::FormFieldErrors,
+          html_options: Types::HtmlAttributeValue
+        ).void
+      end
       def initialize(
         name: nil,
         label: nil,
@@ -15,7 +34,7 @@ module HakumiComponents
         default_checked: false,
         disabled: false,
         loading: false,
-        size: :middle,
+        size: :default,
         checked_text: nil,
         unchecked_text: nil,
         standalone: true,
@@ -23,10 +42,10 @@ module HakumiComponents
         errors: [],
         **html_options
       )
-        @name = name || generate_id("switch")
+        @name = T.let(name || generate_id("switch"), Types::FormFieldName)
         @label = label
         @caption = caption
-        @checked = checked.nil? ? default_checked : checked
+        @checked = T.let(checked.nil? ? default_checked : checked, T::Boolean)
         @disabled = disabled
         @loading = loading
         @size = size
@@ -34,19 +53,31 @@ module HakumiComponents
         @unchecked_text = unchecked_text
         @standalone = standalone
         @required = required
-        @errors = Array(errors)
-        @wrapper_class = html_options.delete(:wrapper_class)
-        @html_options = html_options
+        @errors = T.let(errors, Types::FormFieldErrors)
+        wrapper_class = html_options.delete(:wrapper_class)
+        @wrapper_class = T.let(wrapper_class.is_a?(String) ? wrapper_class : nil, T.nilable(String))
+        @html_options = T.let(html_options, Types::HtmlAttributes)
+        initialize_form_field_contract!(
+          name: @name,
+          label: @label,
+          caption: @caption,
+          errors: @errors,
+          standalone: @standalone,
+          required: @required,
+          html_options: @html_options
+        )
 
         validate_props!
       end
 
       private
 
+      sig { void }
       def validate_props!
         validate_inclusion!(:size, SIZES)
       end
 
+      sig { returns(String) }
       def wrapper_classes
         class_names(
           "switch",
@@ -54,49 +85,42 @@ module HakumiComponents
             checked: @checked,
             disabled: @disabled,
             loading: @loading,
-            @size => (@size != :middle)
+            @size => (@size != :default)
           },
           [ @wrapper_class ]
         )
       end
 
+      sig { returns(Types::HtmlAttributes) }
       def wrapper_attributes
-        data_attrs = {
-          controller: "hakumi--switch",
-          hakumi__switch_checked_value: @checked,
-          hakumi__switch_disabled_value: @disabled,
-          hakumi__switch_loading_value: @loading
-        }
-
-        # Merge additional data attributes from html_options
-        if @html_options[:data]
-          data_attrs = data_attrs.merge(@html_options[:data])
-        end
-
-        attrs = {
-          class: wrapper_classes,
-          role: "switch",
-          tabindex: (@disabled || @loading) ? "-1" : "0",
-          "aria-checked": @checked.to_s,
-          "aria-disabled": (@disabled || @loading).to_s,
-          data: data_attrs
-        }
-
-        # Merge id if provided
-        attrs[:id] = @html_options[:id] if @html_options[:id]
-
-        attrs
+        merge_attributes(
+          {
+            class: wrapper_classes,
+            role: "switch",
+            tabindex: (@disabled || @loading) ? "-1" : "0",
+            "aria-checked": @checked.to_s,
+            "aria-disabled": (@disabled || @loading).to_s,
+            data: {
+              controller: "hakumi--switch",
+              hakumi__switch_checked_value: @checked,
+              hakumi__switch_disabled_value: @disabled,
+              hakumi__switch_loading_value: @loading
+            }
+          },
+          @html_options.except(:class, :wrapper_class)
+        )
       end
 
+      sig { returns(Types::HtmlAttributes) }
       def input_attributes
         attrs = {
           type: "checkbox",
-          name: @name,
+          name: form_field_name,
           id: input_id,
           class: [ "hakumi-switch-input", @html_options[:class] ].compact.join(" "),
           checked: @checked ? true : nil,
           disabled: (@disabled || @loading) ? true : nil,
-          "aria-invalid": has_error? ? "true" : nil,
+          "aria-invalid": error? ? "true" : nil,
           "aria-describedby": describedby_ids,
           tabindex: "-1",
           data: {
@@ -112,10 +136,12 @@ module HakumiComponents
         attrs.merge(@html_options.except(:data, :class))
       end
 
+      sig { returns(Types::Renderable) }
       def checked_content
         render_value(@checked_text)
       end
 
+      sig { returns(Types::Renderable) }
       def unchecked_content
         render_value(@unchecked_text)
       end

data/app/components/hakumi_components/table/column/component.rb

@@ -1,9 +1,44 @@
+# typed: strict
 # frozen_string_literal: true
 
 module HakumiComponents
   module Table
     module Column
       class Component < HakumiComponents::BaseComponent
+        extend T::Sig
+
+        sig do
+          params(
+            title: HakumiComponents::Table::DefinitionTypes::DefinitionValue,
+            data_index: T.nilable(HakumiComponents::Table::DefinitionTypes::ColumnKey),
+            key: T.nilable(HakumiComponents::Table::DefinitionTypes::ColumnKey),
+            align: T.nilable(Symbol),
+            width: HakumiComponents::Table::DefinitionTypes::WidthValue,
+            ellipsis: HakumiComponents::Table::DefinitionTypes::DefinitionValue,
+            sorter: HakumiComponents::Table::DefinitionTypes::SorterValue,
+            sort_directions: T.nilable(T::Array[Symbol]),
+            sort_order: T.nilable(Symbol),
+            default_sort_order: T.nilable(Symbol),
+            filters: T.nilable(T::Array[HakumiComponents::Table::DefinitionTypes::DefinitionHash]),
+            filter_multiple: T::Boolean,
+            filtered_value: T.nilable(HakumiComponents::Table::DefinitionTypes::ScalarList),
+            default_filtered_value: T.nilable(HakumiComponents::Table::DefinitionTypes::ScalarList),
+            filter_mode: T.nilable(Symbol),
+            filter_search: HakumiComponents::Table::DefinitionTypes::SearchValue,
+            hidden: T::Boolean,
+            on_cell: T.nilable(Proc),
+            class_name: T.nilable(String),
+            responsive: T.nilable(T::Array[Symbol]),
+            fixed: T.nilable(Symbol),
+            editable: HakumiComponents::Table::DefinitionTypes::DefinitionValue,
+            should_cell_update: T.nilable(HakumiComponents::Table::DefinitionTypes::ColumnKey),
+            drag_handle: T::Boolean,
+            selection: T::Boolean,
+            expand: T::Boolean,
+            extra: HakumiComponents::Table::DefinitionTypes::DefinitionValue,
+            block: T.nilable(Proc)
+          ).void
+        end
         def initialize(
           title:,
           data_index: nil,
@@ -24,32 +59,47 @@ module HakumiComponents
           hidden: false,
           on_cell: nil,
           class_name: nil,
-          **options,
+          responsive: nil,
+          fixed: nil,
+          editable: nil,
+          should_cell_update: nil,
+          drag_handle: false,
+          selection: false,
+          expand: false,
+          **extra,
           &block
         )
-          @title = title
-          @data_index = data_index
-          @key = key
-          @align = align
-          @width = width
-          @ellipsis = ellipsis
-          @sorter = sorter
-          @sort_directions = sort_directions
-          @sort_order = sort_order
-          @default_sort_order = default_sort_order
-          @filters = filters
-          @filter_multiple = filter_multiple
-          @filtered_value = filtered_value
-          @default_filtered_value = default_filtered_value
-          @filter_mode = filter_mode
-          @filter_search = filter_search
-          @hidden = hidden
-          @on_cell = on_cell
-          @class_name = class_name
-          @options = options
-          @block = block
+          @title = T.let(title, HakumiComponents::Table::DefinitionTypes::DefinitionValue)
+          @data_index = T.let(data_index, T.nilable(HakumiComponents::Table::DefinitionTypes::ColumnKey))
+          @key = T.let(key, T.nilable(HakumiComponents::Table::DefinitionTypes::ColumnKey))
+          @align = T.let(align, T.nilable(Symbol))
+          @width = T.let(width, HakumiComponents::Table::DefinitionTypes::WidthValue)
+          @ellipsis = T.let(ellipsis, HakumiComponents::Table::DefinitionTypes::DefinitionValue)
+          @sorter = T.let(sorter, HakumiComponents::Table::DefinitionTypes::SorterValue)
+          @sort_directions = T.let(sort_directions, T.nilable(T::Array[Symbol]))
+          @sort_order = T.let(sort_order, T.nilable(Symbol))
+          @default_sort_order = T.let(default_sort_order, T.nilable(Symbol))
+          @filters = T.let(filters, T.nilable(T::Array[HakumiComponents::Table::DefinitionTypes::DefinitionHash]))
+          @filter_multiple = T.let(filter_multiple, T::Boolean)
+          @filtered_value = T.let(filtered_value, T.nilable(HakumiComponents::Table::DefinitionTypes::ScalarList))
+          @default_filtered_value = T.let(default_filtered_value, T.nilable(HakumiComponents::Table::DefinitionTypes::ScalarList))
+          @filter_mode = T.let(filter_mode, T.nilable(Symbol))
+          @filter_search = T.let(filter_search, HakumiComponents::Table::DefinitionTypes::SearchValue)
+          @hidden = T.let(hidden, T::Boolean)
+          @on_cell = T.let(on_cell, T.nilable(Proc))
+          @class_name = T.let(class_name, T.nilable(String))
+          @responsive = T.let(responsive, T.nilable(T::Array[Symbol]))
+          @fixed = T.let(fixed, T.nilable(Symbol))
+          @editable = T.let(editable, HakumiComponents::Table::DefinitionTypes::DefinitionValue)
+          @should_cell_update = T.let(should_cell_update, T.nilable(HakumiComponents::Table::DefinitionTypes::ColumnKey))
+          @drag_handle = T.let(drag_handle, T::Boolean)
+          @selection = T.let(selection, T::Boolean)
+          @expand = T.let(expand, T::Boolean)
+          @extra = T.let(extra, T::Hash[Symbol, HakumiComponents::Table::DefinitionTypes::DefinitionValue])
+          @block = T.let(block, T.nilable(Proc))
         end
 
+        sig { returns(HakumiComponents::Table::DefinitionTypes::DefinitionHash) }
         def to_h
           {
             title: @title,
@@ -71,8 +121,15 @@ module HakumiComponents
             hidden: @hidden,
             on_cell: @on_cell,
             class_name: @class_name,
+            responsive: @responsive,
+            fixed: @fixed,
+            editable: @editable,
+            should_cell_update: @should_cell_update,
+            drag_handle: @drag_handle,
+            selection: @selection,
+            expand: @expand,
             render: @block
-          }.merge(@options)
+          }.merge(@extra)
         end
       end
     end