hakumi_components 0.1.17.pre → 0.1.19.pre

data/app/components/{hakumi → hakumi_components}/select/component.html.erb

@@ -1,18 +1,18 @@
 <% select_control = capture do %>
   <div <%= tag.attributes(wrapper_attributes) %>>
     <input type="hidden"
-           name="<%= @name %>"
+           name="<%= form_field_name %>"
            id="<%= input_id %>"
-           value="<%= @value %>"
+           value="<%= selection_control_value %>"
            data-hakumi--select-target="input"
-           <%= 'required' if @required %>
-           <%= "aria-invalid=#{has_error?}" if has_error? %>
+           <%= 'required' if form_field_required %>
+           <%= "aria-invalid=#{error?}" if error? %>
            <%= "aria-describedby=#{describedby_ids}" if describedby_ids %>>
 
     <% if borderless? %>
       <div class="hakumi-select-selector" <%= "data-action=click->hakumi--select#toggle" unless hover_trigger? %>>
         <span class="hakumi-select-selection-item" data-hakumi--select-target="label" style="display: none;"></span>
-        <%= render Hakumi::Icon::Component.new(name: icon || :ellipsis) %>
+        <%= render HakumiComponents::Icon::Component.new(name: icon || :ellipsis) %>
       </div>
     <% else %>
       <div class="hakumi-select-selector" data-action="click->hakumi--select#toggle">
@@ -23,13 +23,13 @@
                    data-hakumi--select-target="searchInput"
                    data-action="input->hakumi--select#onSearchInput keydown->hakumi--select#onSearchKeydown"
                    autocomplete="off"
-                   placeholder="<%= @placeholder %>"
+                   placeholder="<%= selection_control_placeholder %>"
                    value="<%= selected_label || '' %>"
                    role="combobox"
                    aria-haspopup="listbox"
-                   aria-owns="<%= @name %>_list"
+                   aria-owns="<%= list_id %>"
                    aria-autocomplete="list"
-                   aria-controls="<%= @name %>_list"
+                   aria-controls="<%= list_id %>"
                    aria-activedescendant="">
           </span>
         <% else %>
@@ -39,41 +39,41 @@
             <span class="hakumi-select-selection-item" data-hakumi--select-target="label" style="display: none;"></span>
           <% end %>
 
-          <% if @placeholder %>
+          <% if selection_control_placeholder %>
             <span class="hakumi-select-selection-placeholder"
                   data-hakumi--select-target="placeholder"
                   style="<%= selected_label ? 'display: none;' : '' %>">
-              <%= @placeholder %>
+              <%= selection_control_placeholder %>
             </span>
           <% end %>
         <% end %>
       </div>
 
-      <% if @allow_clear %>
+      <% if selection_control_allow_clear %>
         <span class="hakumi-select-clear"
               data-action="click->hakumi--select#clear"
-              style="<%= @value.present? ? '' : 'display: none;' %>"
+              style="<%= selection_control_has_value? ? '' : 'display: none;' %>"
               data-hakumi--select-target="clearBtn">
-          <%= render Hakumi::Icon::Component.new(name: :close_circle, theme: :filled) %>
+          <%= render HakumiComponents::Icon::Component.new(name: :close_circle, theme: :filled) %>
         </span>
       <% end %>
 
       <span class="hakumi-select-arrow">
-        <%= render Hakumi::Icon::Component.new(name: :down) %>
+        <%= render HakumiComponents::Icon::Component.new(name: :down) %>
       </span>
     <% end %>
 
     <div class="hakumi-select-dropdown hakumi-select-dropdown-hidden" data-hakumi--select-target="dropdown">
-      <div class="rc-virtual-list-holder-inner" role="listbox" id="<%= @name %>_list">
-        <% formatted_options.each do |label, value| %>
-          <div class="hakumi-select-item hakumi-select-item-option <%= 'hakumi-select-item-option-selected' if value.to_s == @value.to_s %>"
+      <div class="rc-virtual-list-holder-inner" role="listbox" id="<%= list_id %>">
+        <% normalized_options.each do |option| %>
+          <div class="hakumi-select-item hakumi-select-item-option <%= 'hakumi-select-item-option-selected' if option.value.to_s == selection_control_value.to_s %>"
                role="option"
-               aria-selected="<%= value.to_s == @value.to_s %>"
-               data-value="<%= value %>"
-               data-label="<%= label %>"
+               aria-selected="<%= option.value.to_s == selection_control_value.to_s %>"
+               data-value="<%= option.value %>"
+               data-label="<%= option.label %>"
                data-action="click->hakumi--select#select"
                data-hakumi--select-target="option">
-            <div class="hakumi-select-item-option-content"><%= label %></div>
+            <div class="hakumi-select-item-option-content"><%= option.label %></div>
           </div>
         <% end %>
         <div class="hakumi-select-item-empty" data-hakumi--select-target="empty" style="display: none;">
@@ -84,7 +84,7 @@
   </div>
 <% end %>
 
-<% if @standalone %>
+<% if standalone? %>
   <%= select_control %>
 <% else %>
   <div <%= tag.attributes(form_item_attributes).to_s.html_safe %>>

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

@@ -0,0 +1,176 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Select
+    class Component < HakumiComponents::BaseComponent
+      extend T::Sig
+
+      include HakumiComponents::Concerns::SelectionControl
+
+      VARIANTS = T.let([ :default, :borderless ].freeze, T::Array[Symbol])
+      TRIGGERS = T.let([ :click, :hover ].freeze, T::Array[Symbol])
+
+      sig do
+        params(
+          name: T.nilable(Types::FormFieldName),
+          options: T.nilable(T::Array[HakumiComponents::SelectionControl::Coercion::FlatOptionInput]),
+          label: T.nilable(String),
+          caption: T.nilable(String),
+          value: Types::FormFieldValue,
+          placeholder: T.nilable(String),
+          size: Symbol,
+          variant: Symbol,
+          trigger: Symbol,
+          icon: T.nilable(Types::StringOrSymbol),
+          disabled: T::Boolean,
+          required: T::Boolean,
+          allow_clear: T::Boolean,
+          show_search: T::Boolean,
+          standalone: T::Boolean,
+          rules: T.nilable(T::Array[Types::ValidationRule]),
+          errors: Types::FormFieldErrors,
+          html_options: Types::HtmlAttributeValue
+        ).void
+      end
+      def initialize(
+        name: nil,
+        options: [],
+        label: nil,
+        caption: nil,
+        value: nil,
+        placeholder: nil,
+        size: :default,
+        variant: :default,
+        trigger: :click,
+        icon: nil,
+        disabled: false,
+        required: false,
+        allow_clear: false,
+        show_search: false,
+        standalone: true,
+        rules: nil,
+        errors: [],
+        **html_options
+      )
+        @name = T.let(name || generate_id("select"), Types::FormFieldName)
+        @options = T.let(HakumiComponents::SelectionControl::Coercion.options(Array(options)), T::Array[HakumiComponents::SelectionControl::Option])
+        @label = label
+        @caption = caption
+        @value = T.let(value, Types::FormFieldValue)
+        @placeholder = placeholder
+        @size = size
+        @variant = variant
+        @trigger = trigger
+        @icon = icon
+        @disabled = disabled
+        @required = required
+        @allow_clear = allow_clear
+        @show_search = show_search
+        @standalone = standalone
+        @rules = T.let(rules, T.nilable(T::Array[Types::ValidationRule]))
+        @errors = T.let(errors, Types::FormFieldErrors)
+        @html_options = T.let(html_options, Types::HtmlAttributes)
+        initialize_selection_control_contract!(
+          name: @name,
+          label: @label,
+          caption: @caption,
+          value: @value,
+          placeholder: @placeholder,
+          size: @size,
+          disabled: @disabled,
+          allow_clear: @allow_clear,
+          errors: @errors,
+          standalone: @standalone,
+          required: @required,
+          html_options: @html_options,
+          rules: @rules
+        )
+
+        validate_props!
+      end
+
+      sig { returns(Symbol) }
+      attr_reader :variant
+
+      sig { returns(Symbol) }
+      attr_reader :trigger
+
+      sig { returns(T.nilable(Types::StringOrSymbol)) }
+      attr_reader :icon
+
+      private
+
+      sig { returns(T::Array[HakumiComponents::SelectionControl::Option]) }
+      attr_reader :options
+
+      sig { void }
+      def validate_props!
+        validate_inclusion!(:size, SIZES)
+        validate_inclusion!(:variant, VARIANTS)
+        validate_inclusion!(:trigger, TRIGGERS)
+      end
+
+      sig { returns(String) }
+      def select_wrapper_classes
+        class_names(
+          "select",
+          {
+            lg: selection_control_size == :large,
+            sm: selection_control_size == :small,
+            borderless: @variant == :borderless,
+            "hover-trigger": @trigger == :hover,
+            disabled: selection_control_disabled,
+            "show-search": @show_search,
+            "allow-clear": selection_control_allow_clear,
+            "has-value": selection_control_has_value?
+          },
+          [ selection_control_html_class_name ]
+        )
+      end
+
+      sig { returns(T::Boolean) }
+      def borderless?
+        @variant == :borderless
+      end
+
+      sig { returns(T::Boolean) }
+      def hover_trigger?
+        @trigger == :hover
+      end
+
+      sig { returns(Types::HtmlAttributes) }
+      def wrapper_attributes
+        base_attrs = {
+          class: select_wrapper_classes,
+          data: {
+            controller: "hakumi--select",
+            hakumi__select_allow_clear_value: selection_control_allow_clear,
+            hakumi__select_disabled_value: selection_control_disabled,
+            hakumi__select_trigger_value: @trigger.to_s
+          }
+        }
+
+        merge_attributes(base_attrs, selection_control_html_options_without_class)
+      end
+
+      sig { returns(T.nilable(String)) }
+      def selected_label
+        return nil unless selection_control_has_value?
+
+        option = options.find { |item| item.value.to_s == selection_control_value.to_s }
+        option ? option.label : selection_control_value.to_s
+      end
+
+      sig { returns(String) }
+      def list_id
+        "#{form_field_name}_list"
+      end
+
+      sig { returns(T::Array[HakumiComponents::SelectionControl::Option]) }
+      def normalized_options
+        options
+      end
+    end
+  end
+end

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

@@ -0,0 +1,161 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module SelectionControl
+    module Coercion
+      extend T::Sig
+      extend self
+
+      FlatOptionHash = T.type_alias { T::Hash[Types::HtmlKey, T.nilable(Types::ValidationPrimitive)] }
+      FlatOptionTuple = T.type_alias { [ T.nilable(Types::ValidationPrimitive), T.nilable(Types::ValidationPrimitive) ] }
+      FlatOptionInput = T.type_alias do
+        T.any(
+          Option,
+          FlatOptionHash,
+          FlatOptionTuple,
+          HakumiComponents::Types::FormFieldScalar
+        )
+      end
+      GroupEntryHash = T.type_alias do
+        T::Hash[
+          Types::HtmlKey,
+          T.nilable(
+            T.any(
+              Types::ValidationComparable,
+              T::Array[FlatOptionInput]
+            )
+          )
+        ]
+      end
+      EntryInput = T.type_alias { T.any(Entry, FlatOptionInput, GroupEntryHash) }
+      TreeNodeInput = T.type_alias { HakumiComponents::SelectionControl::TreeNode::Input }
+      ScalarInput = T.type_alias do
+        T.nilable(T.any(Types::FormFieldScalar, Date, Time, DateTime, ActiveSupport::TimeWithZone, ActiveSupport::SafeBuffer))
+      end
+
+      sig do
+        params(
+          value: ScalarInput,
+          fallback: ScalarInput
+        ).returns(HakumiComponents::Types::FormFieldScalar)
+      end
+      def scalar(value, fallback:)
+        value.nil? ? fallback : value
+      end
+
+      sig { params(options: T::Array[FlatOptionInput]).returns(T::Array[Option]) }
+      def options(options)
+        options.filter_map { |option| normalize_option(option) }
+      end
+
+      sig { params(options: T::Array[EntryInput]).returns(T::Array[Entry]) }
+      def entries(options)
+        options.filter_map { |option| normalize_entry(option) }
+      end
+
+      sig { params(options: T::Array[TreeNodeInput]).returns(T::Array[HakumiComponents::SelectionControl::TreeNode]) }
+      def tree_nodes(options)
+        options.filter_map { |option| normalize_tree_node(option) }
+      end
+
+      private
+
+      sig { params(option: FlatOptionInput).returns(T.nilable(Option)) }
+      def normalize_option(option)
+        case option
+        when nil
+          nil
+        when Option
+          option
+        when Hash
+          label = option[:label] || option["label"]
+          value = scalar(option[:value] || option["value"], fallback: label)
+          return nil if label.nil?
+
+          Option.new(label: label.to_s, value: value)
+        when Array
+          label, value = option
+          return nil if label.nil?
+
+          Option.new(label: label.to_s, value: scalar(value, fallback: label))
+        else
+          Option.new(label: option.to_s, value: scalar(option, fallback: option))
+        end
+      end
+
+      sig { params(option: EntryInput).returns(T.nilable(Entry)) }
+      def normalize_entry(option)
+        case option
+        when Entry
+          option
+        when Hash
+          group_options = option[:options] || option["options"]
+          return normalize_option(option) if group_options.nil?
+
+          label = option[:label] || option["label"]
+          normalized_group_options = self.options(Kernel.Array(group_options))
+          return nil if label.nil? || normalized_group_options.empty?
+
+          OptionGroup.new(label: label.to_s, options: normalized_group_options)
+        else
+          normalize_option(option)
+        end
+      end
+
+      sig { params(option: TreeNodeInput).returns(T.nilable(HakumiComponents::SelectionControl::TreeNode)) }
+      def normalize_tree_node(option)
+        return option if option.is_a?(HakumiComponents::SelectionControl::TreeNode)
+        return nil unless option.is_a?(Hash)
+
+        label = option[:label] || option["label"]
+        value = normalize_tree_node_scalar(option[:value] || option["value"], fallback: label)
+        return nil if label.nil?
+        return nil if value.nil?
+
+        children = option[:children] || option["children"]
+        normalized_children = if children.is_a?(Array)
+          children.filter_map do |entry|
+            entry if entry.is_a?(Hash) || entry.is_a?(HakumiComponents::SelectionControl::TreeNode)
+          end
+        else
+          []
+        end
+
+        HakumiComponents::SelectionControl::TreeNode.new(
+          label: label.to_s,
+          value: value,
+          children: tree_nodes(normalized_children),
+          disabled: option[:disabled] == true || option["disabled"] == true,
+          selectable: option[:selectable] != false && option["selectable"] != false,
+          checkable: option[:checkable] != false && option["checkable"] != false,
+          disable_checkbox: option[:disable_checkbox] == true || option["disable_checkbox"] == true,
+          icon: normalize_icon(option[:icon] || option["icon"]),
+          switcher_icon: normalize_icon(option[:switcher_icon] || option["switcher_icon"]),
+          async: option[:async] == true || option["async"] == true,
+          loading: option[:loading] == true || option["loading"] == true
+        )
+      end
+
+      sig { params(value: HakumiComponents::SelectionControl::TreeNode::RawValue).returns(T.nilable(String)) }
+      def normalize_icon(value)
+        return value.to_s if value.is_a?(String) || value.is_a?(Symbol)
+
+        nil
+      end
+
+      sig do
+        params(
+          value: HakumiComponents::SelectionControl::TreeNode::RawValue,
+          fallback: HakumiComponents::SelectionControl::TreeNode::RawValue
+        ).returns(T.nilable(HakumiComponents::Types::FormFieldScalar))
+      end
+      def normalize_tree_node_scalar(value, fallback:)
+        candidate = value.nil? ? fallback : value
+        return candidate if candidate.is_a?(String) || candidate.is_a?(Symbol) || candidate.is_a?(Numeric) || candidate == true || candidate == false
+
+        nil
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module SelectionControl
+    module Entry
+      extend T::Helpers
+      extend T::Sig
+
+      interface!
+
+      sig { abstract.returns(T::Boolean) }
+      def option?; end
+
+      sig { abstract.returns(T::Boolean) }
+      def group?; end
+
+      sig { abstract.returns(String) }
+      def label; end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module SelectionControl
+    class Option
+      extend T::Sig
+
+      include Entry
+
+      sig { params(label: String, value: HakumiComponents::Types::FormFieldScalar).void }
+      def initialize(label:, value:)
+        @label = label
+        @value = value
+      end
+
+      sig { override.returns(T::Boolean) }
+      def option?
+        true
+      end
+
+      sig { override.returns(T::Boolean) }
+      def group?
+        false
+      end
+
+      sig { override.returns(String) }
+      attr_reader :label
+
+      sig { returns(HakumiComponents::Types::FormFieldScalar) }
+      attr_reader :value
+
+      sig { returns(T::Hash[Symbol, HakumiComponents::Types::FormFieldScalar]) }
+      def to_h
+        {
+          label: @label,
+          value: @value
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module SelectionControl
+    class OptionGroup
+      extend T::Sig
+
+      include Entry
+
+      sig { params(label: String, options: T::Array[Option]).void }
+      def initialize(label:, options:)
+        @label = label
+        @options = options
+      end
+
+      sig { override.returns(T::Boolean) }
+      def option?
+        false
+      end
+
+      sig { override.returns(T::Boolean) }
+      def group?
+        true
+      end
+
+      sig { override.returns(String) }
+      attr_reader :label
+
+      sig { returns(T::Array[Option]) }
+      attr_reader :options
+    end
+  end
+end

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

@@ -0,0 +1,123 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module SelectionControl
+    class TreeNode
+      extend T::Sig
+
+      RawValue = T.type_alias do
+        T.nilable(T.any(String, Symbol, Numeric, T::Boolean, T::Array[T.untyped], T::Hash[Types::HtmlKey, T.untyped]))
+      end
+      InputHash = T.type_alias { T::Hash[Types::HtmlKey, RawValue] }
+      Input = T.type_alias { T.any(TreeNode, InputHash) }
+      Payload = T.type_alias { T::Hash[Symbol, T.nilable(T.any(String, Symbol, Numeric, T::Boolean, T::Array[T.untyped]))] }
+
+      sig do
+        params(
+          label: String,
+          value: HakumiComponents::Types::FormFieldScalar,
+          children: T::Array[TreeNode],
+          disabled: T::Boolean,
+          selectable: T::Boolean,
+          checkable: T::Boolean,
+          disable_checkbox: T::Boolean,
+          icon: T.nilable(String),
+          switcher_icon: T.nilable(String),
+          async: T::Boolean,
+          loading: T::Boolean
+        ).void
+      end
+      def initialize(
+        label:,
+        value:,
+        children: [],
+        disabled: false,
+        selectable: true,
+        checkable: true,
+        disable_checkbox: false,
+        icon: nil,
+        switcher_icon: nil,
+        async: false,
+        loading: false
+      )
+        @label = label
+        @value = value
+        @children = children
+        @disabled = disabled
+        @selectable = selectable
+        @checkable = checkable
+        @disable_checkbox = disable_checkbox
+        @icon = icon
+        @switcher_icon = switcher_icon
+        @async = async
+        @loading = loading
+      end
+
+      sig { returns(String) }
+      attr_reader :label
+
+      sig { returns(HakumiComponents::Types::FormFieldScalar) }
+      attr_reader :value
+
+      sig { returns(T::Array[TreeNode]) }
+      attr_reader :children
+
+      sig { returns(T::Boolean) }
+      attr_reader :disabled
+
+      sig { returns(T::Boolean) }
+      attr_reader :selectable
+
+      sig { returns(T::Boolean) }
+      attr_reader :checkable
+
+      sig { returns(T::Boolean) }
+      attr_reader :disable_checkbox
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :icon
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :switcher_icon
+
+      sig { returns(T::Boolean) }
+      attr_reader :async
+
+      sig { returns(T::Boolean) }
+      attr_reader :loading
+
+      sig { returns(String) }
+      def string_value
+        @value.to_s
+      end
+
+      sig { returns(Payload) }
+      def to_tree_node
+        {
+          key: string_value,
+          title: @label,
+          children: @children.map(&:to_tree_node),
+          disabled: @disabled,
+          selectable: @selectable,
+          checkable: @checkable,
+          disable_checkbox: @disable_checkbox,
+          icon: @icon,
+          switcher_icon: @switcher_icon,
+          async: @async,
+          loading: @loading
+        }.compact
+      end
+
+      sig { returns(Payload) }
+      def to_cascader_option
+        {
+          value: @value,
+          label: @label,
+          disabled: @disabled,
+          children: @children.map(&:to_cascader_option)
+        }.compact
+      end
+    end
+  end
+end