hakumi_components 0.1.18.pre → 0.1.19.pre

data/app/components/hakumi_components/concerns/form_field.rb

@@ -1,128 +1,168 @@
+# typed: strict
 # frozen_string_literal: true
 
 module HakumiComponents
   module Concerns
-    # Shared behavior for form field components
-    # Provides common methods for handling errors, labels, captions, and accessibility
     module FormField
-      attr_reader :name, :label, :caption, :errors, :required, :size, :standalone
+      extend T::Sig
+      extend T::Helpers
 
-      # Check if field has validation errors
-      #
-      # @return [Boolean]
-      def has_error?
-        @errors.any?
+      abstract!
+
+      include FormFieldInterface
+
+      requires_ancestor { HakumiComponents::BaseComponent }
+
+      sig { override.returns(HakumiComponents::Concerns::FormFieldContract) }
+      def form_field_contract
+        contract = T.let(@form_field_contract, T.nilable(HakumiComponents::Concerns::FormFieldContract))
+        return contract unless contract.nil?
+
+        Kernel.raise "form_field_contract must be initialized"
+      end
+
+      sig { returns(Types::FormFieldName) }
+      def form_field_name
+        form_field_contract.name
+      end
+
+      sig { returns(T.nilable(String)) }
+      def form_field_label
+        form_field_contract.label
+      end
+
+      sig { returns(T.nilable(String)) }
+      def form_field_caption
+        form_field_contract.caption
+      end
+
+      sig { returns(Types::FormFieldErrors) }
+      def form_field_errors
+        form_field_contract.errors
+      end
+
+      sig { returns(T::Boolean) }
+      def form_field_standalone
+        form_field_contract.standalone
+      end
+
+      sig { returns(T::Boolean) }
+      def form_field_required
+        form_field_contract.required
+      end
+
+      sig { returns(Types::HtmlAttributes) }
+      def form_field_html_options
+        form_field_contract.html_options
+      end
+
+      sig { returns(T.nilable(T::Array[Types::ValidationRule])) }
+      def form_field_rules
+        form_field_contract.rules
+      end
+
+      sig { returns(T::Boolean) }
+      def error?
+        form_field_errors.any?
       end
 
-      # Check if component is in standalone mode
-      #
-      # @return [Boolean]
+      sig { returns(T::Boolean) }
       def standalone?
-        @standalone
+        form_field_standalone
       end
 
-      # Get the input field ID
-      # Works with both @html_options and @html_attrs
-      #
-      # @return [String]
+      sig { returns(Types::StringOrSymbol) }
       def input_id
-        options = instance_variable_defined?(:@html_options) ? @html_options : @html_attrs
-        options&.dig(:id) || @name
+        html_options = form_field_html_options
+        id = html_options[:id]
+        return id if id.is_a?(String) || id.is_a?(Symbol)
+
+        form_field_name
       end
 
-      # Generate CSS classes for form item wrapper
-      #
-      # @return [String]
+      sig { returns(String) }
       def form_item_classes
         class_names(
           "form-item",
           {
-            "has-error": has_error?,
-            "with-help": has_error? || @caption
+            "has-error": error?,
+            "with-help": error? || !caption_blank?
           }
         )
       end
 
-      # Generate aria-describedby attribute value
-      #
-      # @return [String, nil]
+      sig { returns(T.nilable(String)) }
       def describedby_ids
-        # @type var ids: Array[String]
-        ids = []
-        ids << "#{@name}_caption" if @caption
-        ids << "#{@name}_error" if has_error?
-        ids.any? ? ids.join(" ") : nil
+        ids = T.let([], T::Array[String])
+        ids << "#{form_field_name}_caption" unless caption_blank?
+        ids << "#{form_field_name}_error" if error?
+        ids.empty? ? nil : ids.join(" ")
       end
 
-      # Get first error message
-      #
-      # @return [String, nil]
+      sig { returns(T.nilable(String)) }
       def error_message
-        @errors.first if has_error?
+        form_field_errors.first
       end
 
-      # Render label element (wraps label in div for proper styling)
-      #
-      # @param field_id [String] ID of the input field
-      # @return [String, nil]
+      sig { params(field_id: T.nilable(Types::StringOrSymbol)).returns(T.nilable(ActiveSupport::SafeBuffer)) }
       def render_label(field_id: nil)
-        return nil if @label.blank?
+        label = form_field_label
+        return nil if label.nil? || label.strip.empty?
 
         content_tag(:div, class: "hakumi-form-item-label") do
-          content_tag(:label, for: field_id || @name) do
+          content_tag(:label, for: field_id || form_field_name) do
             safe_join([
-              (@required ? content_tag(:span, "*", class: "hakumi-form-item-required-mark") : nil),
-              @label
+              (form_field_required ? content_tag(:span, "*", class: "hakumi-form-item-required-mark") : nil),
+              label
             ].compact)
           end
         end
       end
 
-      # Render caption (help text) element
-      #
-      # @return [String, nil]
+      sig { returns(T.nilable(ActiveSupport::SafeBuffer)) }
       def render_caption
-        return nil if @caption.blank?
+        caption = form_field_caption
+        return nil if caption.nil? || caption.strip.empty?
 
-        content_tag(:div, @caption, class: "hakumi-form-item-extra", id: "#{@name}_caption")
+        content_tag(:div, caption, class: "hakumi-form-item-extra", id: "#{form_field_name}_caption")
       end
 
-      # Render error message element
-      #
-      # @return [String, nil]
+      sig { returns(T.nilable(ActiveSupport::SafeBuffer)) }
       def render_error
-        return nil unless has_error?
+        return nil unless error?
 
-        content_tag(:div, error_message,
+        content_tag(
+          :div,
+          error_message,
           class: "hakumi-form-item-explain-error",
-          id: "#{@name}_error",
+          id: "#{form_field_name}_error",
           role: "alert"
         )
       end
 
-      # Render explain section (caption or error)
-      #
-      # @return [String, nil]
+      sig { returns(T.nilable(ActiveSupport::SafeBuffer)) }
       def render_explain
-        return nil unless @caption || has_error?
+        return nil if caption_blank? && !error?
 
-        content_tag(:div, class: "hakumi-form-item-explain") do
-          has_error? ? render_error : render_caption
+        explain_content = if error?
+          render_error
+        else
+          render_caption
         end
+        return nil if explain_content.nil?
+
+        content_tag(:div, class: "hakumi-form-item-explain") { explain_content }
       end
 
-      # Generate form item wrapper attributes
-      #
-      # @param additional_data [Hash] Additional data attributes
-      # @return [Hash]
+      sig { params(additional_data: Types::DataAttributes).returns(Types::HtmlAttributes) }
       def form_item_attributes(additional_data: {})
         data_attrs = additional_data.dup
+        rules = form_field_rules
 
-        # Add controller if rules exist
-        if defined?(@rules) && @rules
+        if rules && !rules.empty?
           data_attrs[:controller] = "hakumi--form-item"
-          data_attrs[:hakumi__form_item_field_name_value] = @name.to_s
-          data_attrs[:hakumi__form_item_rules_value] = @rules.to_json
+          data_attrs[:hakumi__form_item_field_name_value] = form_field_name.to_s
+          data_attrs[:hakumi__form_item_rules_value] = rules.to_json
         end
 
         {
@@ -130,6 +170,67 @@ module HakumiComponents
           data: data_attrs.empty? ? nil : data_attrs
         }.compact
       end
+
+      private
+
+      sig do
+        params(
+          name: Types::FormFieldName,
+          label: T.nilable(String),
+          caption: T.nilable(String),
+          errors: Types::FormFieldErrors,
+          standalone: T::Boolean,
+          required: T::Boolean,
+          html_options: Types::HtmlAttributes,
+          rules: T.nilable(T::Array[Types::ValidationRule])
+        ).returns(HakumiComponents::Concerns::FormFieldContract)
+      end
+      def build_form_field_contract(name:, label:, caption:, errors:, standalone:, required:, html_options:, rules: nil)
+        HakumiComponents::Concerns::FormFieldContract.new(
+          name: name,
+          label: label,
+          caption: caption,
+          errors: errors,
+          standalone: standalone,
+          required: required,
+          html_options: html_options,
+          rules: rules
+        )
+      end
+
+      sig do
+        params(
+          name: Types::FormFieldName,
+          label: T.nilable(String),
+          caption: T.nilable(String),
+          errors: Types::FormFieldErrors,
+          standalone: T::Boolean,
+          required: T::Boolean,
+          html_options: Types::HtmlAttributes,
+          rules: T.nilable(T::Array[Types::ValidationRule])
+        ).void
+      end
+      def initialize_form_field_contract!(name:, label:, caption:, errors:, standalone:, required:, html_options:, rules: nil)
+        @form_field_contract = T.let(
+          build_form_field_contract(
+            name: name,
+            label: label,
+            caption: caption,
+            errors: errors,
+            standalone: standalone,
+            required: required,
+            html_options: html_options,
+            rules: rules
+          ),
+          T.nilable(HakumiComponents::Concerns::FormFieldContract)
+        )
+      end
+
+      sig { returns(T::Boolean) }
+      def caption_blank?
+        caption = form_field_caption
+        caption.nil? || caption.strip.empty?
+      end
     end
   end
 end

data/app/components/hakumi_components/concerns/form_field_contract.rb

@@ -0,0 +1,57 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Concerns
+    class FormFieldContract
+      extend T::Sig
+
+      sig do
+        params(
+          name: Types::FormFieldName,
+          label: T.nilable(String),
+          caption: T.nilable(String),
+          errors: Types::FormFieldErrors,
+          standalone: T::Boolean,
+          required: T::Boolean,
+          html_options: Types::HtmlAttributes,
+          rules: T.nilable(T::Array[Types::ValidationRule])
+        ).void
+      end
+      def initialize(name:, label:, caption:, errors:, standalone:, required:, html_options:, rules:)
+        @name = name
+        @label = label
+        @caption = caption
+        @errors = errors
+        @standalone = standalone
+        @required = required
+        @html_options = html_options
+        @rules = rules
+      end
+
+      sig { returns(Types::FormFieldName) }
+      attr_reader :name
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :label
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :caption
+
+      sig { returns(Types::FormFieldErrors) }
+      attr_reader :errors
+
+      sig { returns(T::Boolean) }
+      attr_reader :standalone
+
+      sig { returns(T::Boolean) }
+      attr_reader :required
+
+      sig { returns(Types::HtmlAttributes) }
+      attr_reader :html_options
+
+      sig { returns(T.nilable(T::Array[Types::ValidationRule])) }
+      attr_reader :rules
+    end
+  end
+end

data/app/components/hakumi_components/concerns/form_field_interface.rb

@@ -0,0 +1,16 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Concerns
+    module FormFieldInterface
+      extend T::Sig
+      extend T::Helpers
+
+      interface!
+
+      sig { abstract.returns(HakumiComponents::Concerns::FormFieldContract) }
+      def form_field_contract; end
+    end
+  end
+end

data/app/components/hakumi_components/concerns/input_control.rb

@@ -0,0 +1,111 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Concerns
+    module InputControl
+      extend T::Sig
+      extend T::Helpers
+
+      abstract!
+
+      include FormField
+      include InputControlInterface
+
+      sig { override.returns(InputControlContract) }
+      def input_control_contract
+        contract = T.let(@input_control_contract, T.nilable(InputControlContract))
+        return contract unless contract.nil?
+
+        Kernel.raise "input_control_contract must be initialized"
+      end
+
+      sig { override.returns(Types::FormFieldValue) }
+      def input_control_value
+        input_control_contract.value
+      end
+
+      sig { override.returns(T.nilable(String)) }
+      def input_control_placeholder
+        input_control_contract.placeholder
+      end
+
+      sig { override.returns(Symbol) }
+      def input_control_size
+        input_control_contract.size
+      end
+
+      sig { override.returns(T::Boolean) }
+      def input_control_disabled
+        input_control_contract.disabled
+      end
+
+      sig { override.returns(T::Boolean) }
+      def input_control_readonly
+        input_control_contract.readonly
+      end
+
+      sig { override.returns(T::Boolean) }
+      def input_control_has_value?
+        value = input_control_value
+        if value.is_a?(Array)
+          return value.any? do |item|
+            next false if item.nil? || item == false
+            next !item.empty? if item.is_a?(String)
+
+            true
+          end
+        end
+
+        return false if value.nil? || value == false
+        return !value.empty? if value.is_a?(String)
+
+        true
+      end
+
+      private
+
+      sig do
+        params(
+          name: Types::FormFieldName,
+          label: T.nilable(String),
+          caption: T.nilable(String),
+          value: Types::FormFieldValue,
+          placeholder: T.nilable(String),
+          size: Symbol,
+          disabled: T::Boolean,
+          readonly: T::Boolean,
+          required: T::Boolean,
+          standalone: T::Boolean,
+          errors: Types::FormFieldErrors,
+          html_options: Types::HtmlAttributes,
+          rules: T.nilable(T::Array[Types::ValidationRule])
+        ).void
+      end
+      def initialize_input_control_contract!(name:, label:, caption:, value:, placeholder:, size:, disabled:, readonly:, required:, standalone:, errors:, html_options:, rules: nil)
+        initialize_form_field_contract!(
+          name: name,
+          label: label,
+          caption: caption,
+          errors: errors,
+          standalone: standalone,
+          required: required,
+          html_options: html_options,
+          rules: rules
+        )
+
+        @input_control_contract = T.let(
+          InputControlContract.new(
+            form_field_contract: form_field_contract,
+            value: value,
+            placeholder: placeholder,
+            size: size,
+            disabled: disabled,
+            readonly: readonly
+          ),
+          T.nilable(InputControlContract)
+        )
+      end
+    end
+  end
+end

data/app/components/hakumi_components/concerns/input_control_contract.rb

@@ -0,0 +1,47 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Concerns
+    class InputControlContract
+      extend T::Sig
+
+      sig do
+        params(
+          form_field_contract: FormFieldContract,
+          value: Types::FormFieldValue,
+          placeholder: T.nilable(String),
+          size: Symbol,
+          disabled: T::Boolean,
+          readonly: T::Boolean
+        ).void
+      end
+      def initialize(form_field_contract:, value:, placeholder:, size:, disabled:, readonly:)
+        @form_field_contract = form_field_contract
+        @value = value
+        @placeholder = placeholder
+        @size = size
+        @disabled = disabled
+        @readonly = readonly
+      end
+
+      sig { returns(FormFieldContract) }
+      attr_reader :form_field_contract
+
+      sig { returns(Types::FormFieldValue) }
+      attr_reader :value
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :placeholder
+
+      sig { returns(Symbol) }
+      attr_reader :size
+
+      sig { returns(T::Boolean) }
+      attr_reader :disabled
+
+      sig { returns(T::Boolean) }
+      attr_reader :readonly
+    end
+  end
+end

data/app/components/hakumi_components/concerns/input_control_interface.rb

@@ -0,0 +1,34 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Concerns
+    module InputControlInterface
+      extend T::Sig
+      extend T::Helpers
+
+      interface!
+
+      sig { abstract.returns(HakumiComponents::Concerns::InputControlContract) }
+      def input_control_contract; end
+
+      sig { abstract.returns(HakumiComponents::Types::FormFieldValue) }
+      def input_control_value; end
+
+      sig { abstract.returns(T.nilable(String)) }
+      def input_control_placeholder; end
+
+      sig { abstract.returns(Symbol) }
+      def input_control_size; end
+
+      sig { abstract.returns(T::Boolean) }
+      def input_control_disabled; end
+
+      sig { abstract.returns(T::Boolean) }
+      def input_control_readonly; end
+
+      sig { abstract.returns(T::Boolean) }
+      def input_control_has_value?; end
+    end
+  end
+end

data/app/components/hakumi_components/concerns/selection_control.rb

@@ -0,0 +1,122 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Concerns
+    module SelectionControl
+      extend T::Sig
+      extend T::Helpers
+
+      abstract!
+
+      include FormField
+      include SelectionControlInterface
+
+      sig { override.returns(SelectionControlContract) }
+      def selection_control_contract
+        contract = T.let(@selection_control_contract, T.nilable(SelectionControlContract))
+        return contract unless contract.nil?
+
+        Kernel.raise "selection_control_contract must be initialized"
+      end
+
+      sig { override.returns(Types::FormFieldValue) }
+      def selection_control_value
+        selection_control_contract.value
+      end
+
+      sig { override.returns(T.nilable(String)) }
+      def selection_control_placeholder
+        selection_control_contract.placeholder
+      end
+
+      sig { override.returns(Symbol) }
+      def selection_control_size
+        selection_control_contract.size
+      end
+
+      sig { override.returns(T::Boolean) }
+      def selection_control_disabled
+        selection_control_contract.disabled
+      end
+
+      sig { override.returns(T::Boolean) }
+      def selection_control_allow_clear
+        selection_control_contract.allow_clear
+      end
+
+      sig { override.returns(T::Boolean) }
+      def selection_control_has_value?
+        value = selection_control_value
+        if value.is_a?(Array)
+          return value.any? do |item|
+            next false if item.nil? || item == false
+            next !item.empty? if item.is_a?(String)
+
+            true
+          end
+        end
+
+        return false if value.nil? || value == false
+        return !value.empty? if value.is_a?(String)
+
+        true
+      end
+
+      private
+
+      sig { returns(T.nilable(String)) }
+      def selection_control_html_class_name
+        css_class = form_field_html_options[:class]
+        css_class.is_a?(String) ? css_class : nil
+      end
+
+      sig { returns(Types::HtmlAttributes) }
+      def selection_control_html_options_without_class
+        form_field_html_options.except(:class)
+      end
+
+      sig do
+        params(
+          name: Types::FormFieldName,
+          label: T.nilable(String),
+          caption: T.nilable(String),
+          value: Types::FormFieldValue,
+          placeholder: T.nilable(String),
+          size: Symbol,
+          disabled: T::Boolean,
+          allow_clear: T::Boolean,
+          required: T::Boolean,
+          standalone: T::Boolean,
+          errors: Types::FormFieldErrors,
+          html_options: Types::HtmlAttributes,
+          rules: T.nilable(T::Array[Types::ValidationRule])
+        ).void
+      end
+      def initialize_selection_control_contract!(name:, label:, caption:, value:, placeholder:, size:, disabled:, allow_clear:, required:, standalone:, errors:, html_options:, rules: nil)
+        initialize_form_field_contract!(
+          name: name,
+          label: label,
+          caption: caption,
+          errors: errors,
+          standalone: standalone,
+          required: required,
+          html_options: html_options,
+          rules: rules
+        )
+
+        @selection_control_contract = T.let(
+          SelectionControlContract.new(
+            form_field_contract: form_field_contract,
+            value: value,
+            placeholder: placeholder,
+            size: size,
+            disabled: disabled,
+            allow_clear: allow_clear
+          ),
+          T.nilable(SelectionControlContract)
+        )
+      end
+    end
+  end
+end