hakumi_components 0.1.18.pre → 0.1.19.pre

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

@@ -1,15 +1,15 @@
 <% tree_select_control = capture do %>
   <div <%= tag.attributes(wrapper_attributes) %>>
     <input type="hidden"
-           name="<%= @name %>"
+           name="<%= form_field_name %>"
            id="<%= input_id %>"
            value="<%= input_value %>"
            data-hakumi--tree-select-target="input"
-           <%= "aria-invalid=#{has_error?}" if has_error? %>
+           <%= "aria-invalid=#{error?}" if error? %>
            <%= "aria-describedby=#{describedby_ids}" if describedby_ids %>>
 
     <div class="hakumi-tree-select-selector" data-hakumi--tree-select-target="selector" data-action="click->hakumi--tree-select#toggle">
-      <% if has_prefix? %>
+      <% if prefix? %>
         <span class="hakumi-tree-select-prefix">
           <% if prefix_icon %>
             <%= render HakumiComponents::Icon::Component.new(name: prefix_icon) %>
@@ -25,20 +25,20 @@
         <span class="hakumi-tree-select-selection-item" data-hakumi--tree-select-target="label" style="display: none;"></span>
       <% end %>
 
-      <% if @placeholder %>
+      <% if selection_control_placeholder %>
         <span class="hakumi-tree-select-selection-placeholder"
               data-hakumi--tree-select-target="placeholder"
               style="<%= display_label ? 'display: none;' : '' %>">
-          <%= @placeholder %>
+          <%= selection_control_placeholder %>
         </span>
       <% end %>
     </div>
 
-    <% if @allow_clear %>
+    <% if selection_control_allow_clear %>
       <span class="hakumi-tree-select-clear"
             data-action="click->hakumi--tree-select#clear"
             data-hakumi--tree-select-target="clearBtn"
-            style="<%= has_value? ? '' : 'display: none;' %>">
+            style="<%= value? ? '' : 'display: none;' %>">
         <%= render HakumiComponents::Icon::Component.new(name: :close_circle, theme: :filled) %>
       </span>
     <% end %>
@@ -51,13 +51,27 @@
       <% if empty_options? %>
         <%= render HakumiComponents::Empty::Component.new(description: "No Data") %>
       <% else %>
-        <%= render HakumiComponents::Tree::Component.new(**tree_component_options) %>
+        <%= render HakumiComponents::Tree::Component.new(
+          nodes: normalized_options.map(&:to_tree_node),
+          checkable: @tree_checkable,
+          selectable: !@tree_checkable,
+          multiple: @multiple,
+          searchable: @show_search,
+          disabled: selection_control_disabled,
+          default_expand_keys: default_expand_keys,
+          default_checked_keys: (@tree_checkable && multi_value?) ? selected_keys : [],
+          default_selected_keys: (@tree_checkable && multi_value?) ? [] : selected_keys,
+          data: {
+            hakumi__tree_select_target: "tree",
+            action: "hakumi--tree:select->hakumi--tree-select#onTreeSelect hakumi--tree:check->hakumi--tree-select#onTreeCheck"
+          }
+        ) %>
       <% end %>
     </div>
   </div>
 <% end %>
 
-<% if @standalone %>
+<% if standalone? %>
   <%= tree_select_control %>
 <% else %>
   <div <%= tag.attributes(form_item_attributes).to_s.html_safe %>>

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

@@ -1,19 +1,49 @@
+# typed: strict
 # frozen_string_literal: true
 
 module HakumiComponents
   module TreeSelect
     class Component < HakumiComponents::BaseComponent
-      include HakumiComponents::Concerns::FormField
-
-      SIZES = [ :small, :middle, :large ].freeze
-      VARIANTS = [ :default, :borderless ].freeze
-      STATUSES = [ nil, :error, :warning ].freeze
-
+      extend T::Sig
+
+      include HakumiComponents::Concerns::SelectionControl
+
+      VARIANTS = T.let([ :default, :borderless ].freeze, T::Array[Symbol])
+      STATUSES = T.let([ nil, :error, :warning ].freeze, T::Array[T.nilable(Symbol)])
+
+      sig do
+        params(
+          name: T.nilable(Types::FormFieldName),
+          options: T.nilable(T::Array[HakumiComponents::SelectionControl::TreeNode]),
+          value: Types::FormFieldValue,
+          placeholder: T.nilable(String),
+          multiple: T::Boolean,
+          tree_checkable: T::Boolean,
+          show_search: T::Boolean,
+          tree_default_expand_all: T::Boolean,
+          tree_selectable_leaf_only: T::Boolean,
+          disabled: T::Boolean,
+          allow_clear: T::Boolean,
+          size: Symbol,
+          variant: Symbol,
+          status: T.nilable(Symbol),
+          max_count: T.nilable(Integer),
+          prefix: Types::Renderable,
+          prefix_icon: T.nilable(Types::StringOrSymbol),
+          label: T.nilable(String),
+          caption: T.nilable(String),
+          rules: T.nilable(T::Array[Types::ValidationRule]),
+          errors: Types::FormFieldErrors,
+          standalone: T::Boolean,
+          required: T::Boolean,
+          html_options: Types::HtmlAttributeValue
+        ).void
+      end
       def initialize(
         name: nil,
         options: [],
         value: nil,
-        placeholder: "Select",
+        placeholder: nil,
         multiple: false,
         tree_checkable: false,
         show_search: false,
@@ -21,7 +51,7 @@ module HakumiComponents
         tree_selectable_leaf_only: false,
         disabled: false,
         allow_clear: false,
-        size: :middle,
+        size: :default,
         variant: :default,
         status: nil,
         max_count: nil,
@@ -29,15 +59,16 @@ module HakumiComponents
         prefix_icon: nil,
         label: nil,
         caption: nil,
+        rules: nil,
         errors: [],
         standalone: true,
         required: false,
         **html_options
       )
-        @name = name || generate_id("tree_select")
-        @options = options
-        @value = value
-        @placeholder = placeholder
+        @name = T.let(name || generate_id("tree_select"), Types::FormFieldName)
+        @options = T.let(options || [], T::Array[HakumiComponents::SelectionControl::TreeNode])
+        @value = T.let(value, Types::FormFieldValue)
+        @placeholder = T.let(placeholder || t_default(:placeholder, default: "Select"), T.nilable(String))
         @multiple = multiple
         @tree_checkable = tree_checkable
         @show_search = show_search
@@ -53,24 +84,45 @@ module HakumiComponents
         @prefix_icon = prefix_icon
         @label = label
         @caption = caption
-        @errors = Array(errors)
+        @rules = T.let(rules, T.nilable(T::Array[Types::ValidationRule]))
+        @errors = T.let(errors, Types::FormFieldErrors)
         @standalone = standalone
         @required = required
-        @html_options = html_options
+        @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
 
-      attr_reader :prefix, :prefix_icon
+      sig { returns(Types::Renderable) }
+      attr_reader :prefix
+
+      sig { returns(T.nilable(Types::StringOrSymbol)) }
+      attr_reader :prefix_icon
 
+      sig { returns(Types::HtmlAttributes) }
       def wrapper_attributes
-        data_attrs = {
+        data_attrs = T.let({
           controller: "hakumi--tree-select",
-          hakumi__tree_select_allow_clear_value: @allow_clear,
-          hakumi__tree_select_disabled_value: @disabled,
+          hakumi__tree_select_allow_clear_value: selection_control_allow_clear,
+          hakumi__tree_select_disabled_value: selection_control_disabled,
           hakumi__tree_select_multiple_value: @multiple,
           hakumi__tree_select_tree_checkable_value: @tree_checkable
-        }
+        }.compact, Types::DataAttributes)
 
         data_attrs[:hakumi__tree_select_max_count_value] = @max_count if @max_count
 
@@ -79,51 +131,32 @@ module HakumiComponents
           data: data_attrs
         }
 
-        merge_attributes(base_attrs, @html_options.except(:class))
+        merge_attributes(base_attrs, selection_control_html_options_without_class)
       end
 
-      def has_prefix?
-        @prefix.present? || @prefix_icon.present?
+      sig { returns(T::Boolean) }
+      def prefix?
+        value_present?(@prefix) || !@prefix_icon.nil?
       end
 
+      sig { returns(T::Boolean) }
       def empty_options?
-        @options.nil? || @options.empty?
+        options.empty?
       end
 
+      sig { returns(T::Boolean) }
       def borderless?
         @variant == :borderless
       end
 
+      sig { returns(T.nilable(Symbol)) }
       def effective_status
-        return :error if has_error?
-        @status
-      end
-
-      def tree_component_options
-        options = {
-          nodes: normalized_options,
-          checkable: @tree_checkable,
-          selectable: !@tree_checkable,
-          multiple: @multiple,
-          searchable: @show_search,
-          disabled: @disabled,
-          default_expand_keys: default_expand_keys,
-          data: {
-            hakumi__tree_select_target: "tree",
-            action: "hakumi--tree:select->hakumi--tree-select#onTreeSelect hakumi--tree:check->hakumi--tree-select#onTreeCheck"
-          }
-        }
+        return :error if error?
 
-        if multi_value?
-          options[:default_checked_keys] = selected_keys if @tree_checkable
-          options[:default_selected_keys] = selected_keys unless @tree_checkable
-        else
-          options[:default_selected_keys] = selected_keys
-        end
-
-        options
+        @status
       end
 
+      sig { returns(T.nilable(String)) }
       def input_value
         if multi_value?
           selected_keys.to_json
@@ -132,6 +165,7 @@ module HakumiComponents
         end
       end
 
+      sig { returns(T.nilable(String)) }
       def display_label
         labels = selected_labels
         return nil if labels.empty?
@@ -139,95 +173,67 @@ module HakumiComponents
         labels.join(", ")
       end
 
-      def has_value?
+      sig { returns(T::Boolean) }
+      def value?
         selected_keys.any?
       end
 
       private
 
+      sig { returns(T::Array[HakumiComponents::SelectionControl::TreeNode]) }
+      attr_reader :options
+
+      sig { void }
       def validate_props!
         validate_inclusion!(:size, SIZES)
         validate_inclusion!(:variant, VARIANTS)
         validate_inclusion!(:status, STATUSES)
       end
 
+      sig { returns(String) }
       def wrapper_classes
         class_names(
           "tree-select",
           {
-            lg: @size == :large,
-            sm: @size == :small,
+            lg: selection_control_size == :large,
+            sm: selection_control_size == :small,
             borderless: borderless?,
-            disabled: @disabled,
-            "allow-clear": @allow_clear,
+            disabled: selection_control_disabled,
+            "allow-clear": selection_control_allow_clear,
             multiple: @multiple,
             checkable: @tree_checkable,
-            "has-value": has_value?,
+            "has-value": value?,
             "status-error": effective_status == :error,
             "status-warning": effective_status == :warning
           },
-          [ @html_options[:class] ]
+          [ selection_control_html_class_name ]
         ).split.uniq.join(" ")
       end
 
+      sig { returns(T::Array[HakumiComponents::SelectionControl::TreeNode]) }
       def normalized_options
-        @normalized_options ||= normalize_options(@options)
-      end
-
-      def normalize_options(options, parent_key: nil)
-        Array(options).map.with_index do |option, index|
-          if option.is_a?(Hash)
-            key = option[:key] || option["key"] || option[:value] || option["value"] || "#{parent_key || 'node'}-#{index}"
-            title = option[:title] || option["title"] || option[:label] || option["label"] || key
-            children = option[:children] || option["children"] || []
-            has_children = children.any?
-
-            # Determine selectability
-            explicit_selectable = option.key?(:selectable) ? option[:selectable] : option.fetch("selectable", nil)
-            selectable = if explicit_selectable.nil?
-              # Apply leaf_only logic if no explicit selectable set
-              @tree_selectable_leaf_only ? !has_children : true
-            else
-              explicit_selectable
-            end
-
-            {
-              key: key.to_s,
-              title: title,
-              children: normalize_options(children, parent_key: key),
-              disabled: option[:disabled] || option["disabled"],
-              selectable: selectable,
-              checkable: option.key?(:checkable) ? option[:checkable] : option.fetch("checkable", true),
-              disable_checkbox: option[:disable_checkbox] || option["disable_checkbox"],
-              icon: option[:icon] || option["icon"],
-              switcher_icon: option[:switcher_icon] || option["switcher_icon"],
-              async: option[:async] || option["async"],
-              loading: option[:loading] || option["loading"]
-            }.compact
-          else
-            {
-              key: option.to_s,
-              title: option,
-              children: []
-            }
-          end
-        end
+        options
       end
 
+      sig { returns(T::Array[String]) }
       def selected_keys
         keys = if multi_value?
-          Array(@value)
+          Array(selection_control_value)
+        elsif selection_control_has_value?
+          [ selection_control_value ]
         else
-          @value.present? ? [ @value ] : []
+          []
         end
 
         keys.map(&:to_s)
       end
 
+      sig { returns(T::Boolean) }
       def multi_value?
         @multiple || @tree_checkable
       end
 
+      sig { returns(T::Array[String]) }
       def selected_labels
         return [] if selected_keys.empty?
 
@@ -235,24 +241,27 @@ module HakumiComponents
         selected_keys.map { |key| label_map[key] || key }
       end
 
-      def build_label_map(options, map = {})
-        Array(options).each do |node|
-          map[node[:key].to_s] = node[:title]
-          build_label_map(node[:children], map) if node[:children].present?
+      sig { params(nodes: T::Array[HakumiComponents::SelectionControl::TreeNode], map: T::Hash[String, String]).returns(T::Hash[String, String]) }
+      def build_label_map(nodes, map = {})
+        nodes.each do |node|
+          map[node.string_value] = node.label
+          build_label_map(node.children, map) if node.children.any?
         end
         map
       end
 
+      sig { returns(T::Array[String]) }
       def default_expand_keys
         return [] unless @tree_default_expand_all
 
         collect_keys(normalized_options)
       end
 
-      def collect_keys(options, keys = [])
-        Array(options).each do |node|
-          keys << node[:key].to_s
-          collect_keys(node[:children], keys) if node[:children].present?
+      sig { params(nodes: T::Array[HakumiComponents::SelectionControl::TreeNode], keys: T::Array[String]).returns(T::Array[String]) }
+      def collect_keys(nodes, keys = [])
+        nodes.each do |node|
+          keys << node.string_value
+          collect_keys(node.children, keys) if node.children.any?
         end
         keys
       end

data/app/components/hakumi_components/typography/base_component.rb

@@ -1,10 +1,30 @@
+# typed: strict
 # frozen_string_literal: true
 
 module HakumiComponents
   module Typography
     class BaseComponent < HakumiComponents::BaseComponent
-      TYPES = [ :secondary, :success, :warning, :danger ].freeze
-
+      extend T::Sig
+
+      TYPES = T.let([ :secondary, :success, :warning, :danger ].freeze, T::Array[Symbol])
+
+      sig do
+        params(
+          type: T.nilable(Symbol),
+          disabled: T::Boolean,
+          mark: T::Boolean,
+          code: T::Boolean,
+          keyboard: T::Boolean,
+          underline: T::Boolean,
+          delete: T::Boolean,
+          strong: T::Boolean,
+          italic: T::Boolean,
+          copyable: T::Boolean,
+          copied_text: T.nilable(String),
+          copy_error_text: T.nilable(String),
+          html_options: Types::HtmlPrimitive
+        ).void
+      end
       def initialize(
         type: nil,
         disabled: false,
@@ -16,74 +36,73 @@ module HakumiComponents
         strong: false,
         italic: false,
         copyable: false,
-        copied_text: "Copied!",
-        copy_error_text: "Copy failed",
+        copied_text: nil,
+        copy_error_text: nil,
         **html_options
       )
-        @type = type
-        @disabled = disabled
-        @mark = mark
-        @code = code
-        @keyboard = keyboard
-        @underline = underline
-        @delete = delete
-        @strong = strong
-        @italic = italic
-        @copyable = copyable
-        @copied_text = copied_text
-        @copy_error_text = copy_error_text
-        @html_options = html_options
+        @type = T.let(type, T.nilable(Symbol))
+        @disabled = T.let(disabled, T::Boolean)
+        @mark = T.let(disabled ? false : mark, T::Boolean)
+        @code = T.let(disabled ? false : code, T::Boolean)
+        @keyboard = T.let(disabled ? false : keyboard, T::Boolean)
+        @underline = T.let(disabled ? false : underline, T::Boolean)
+        @delete = T.let(disabled ? false : delete, T::Boolean)
+        @strong = T.let(strong, T::Boolean)
+        @italic = T.let(italic, T::Boolean)
+        @copyable = T.let(copyable, T::Boolean)
+        @copied_text = T.let(copied_text, T.nilable(String))
+        @copy_error_text = T.let(copy_error_text, T.nilable(String))
+        @html_options = T.let(html_options, Types::HtmlAttributes)
 
         validate_props!
       end
 
+      sig { returns(ActiveSupport::SafeBuffer) }
       def call
         content_tag(tag_name, content_wrapper, wrapper_attributes)
       end
 
       private
 
+      sig { void }
       def validate_props!
         validate_inclusion!(:type, TYPES)
       end
 
+      sig { overridable.returns(Symbol) }
       def tag_name
         :span
       end
 
+      sig { overridable.returns(String) }
       def wrapper_classes
-        modifiers = {}
+        modifiers = T.let({}, Types::ClassModifiers)
         modifiers[@type] = true if @type
         modifiers[:disabled] = true if @disabled
 
-        class_names(
-          "typography",
-          modifiers,
-          [ @html_options[:class] ]
-        )
+        component_classes("typography", modifiers, @html_options)
       end
 
+      sig { overridable.returns(Types::HtmlAttributes) }
       def wrapper_attributes
-        attrs = {
-          class: wrapper_classes
-        }
+        attrs = T.let({ class: wrapper_classes }, Types::HtmlAttributes)
 
         if @copyable
           attrs[:data] = {
             controller: "hakumi--typography",
             action: "click->hakumi--typography#copy",
-            "hakumi--typography-copied-text-value": @copied_text,
-            "hakumi--typography-error-text-value": @copy_error_text
+            "hakumi--typography-copied-text-value": resolved_copied_text,
+            "hakumi--typography-error-text-value": resolved_copy_error_text
           }
         end
 
         merge_attributes(attrs, @html_options.except(:class))
       end
 
+      sig { returns(T.nilable(T.any(String, ActiveSupport::SafeBuffer))) }
       def content_wrapper
-        text = content
+        text = T.let(content, T.nilable(T.any(String, ActiveSupport::SafeBuffer)))
 
-        # Apply wrappers in order
         text = tag.strong(text) if @strong
         text = tag.u(text) if @underline
         text = tag.del(text) if @delete
@@ -92,18 +111,32 @@ module HakumiComponents
         text = tag.kbd(text) if @keyboard
         text = tag.i(text) if @italic
 
-        if @copyable
-          safe_join([ text, copy_icon ])
-        else
-          text
-        end
+        return text unless @copyable
+
+        safe_join([ text, copy_icon ])
       end
 
+      sig { returns(ActiveSupport::SafeBuffer) }
       def copy_icon
-        tag.span(class: "hakumi-typography-copy", role: "button", "aria-label": "Copy") do
+        tag.span(class: "hakumi-typography-copy", role: "button", "aria-label": copy_aria_label) do
           render HakumiComponents::Icon::Component.new(name: :copy)
         end
       end
+
+      sig { returns(String) }
+      def resolved_copied_text
+        @copied_text || t_default(:copied, default: "Copied!")
+      end
+
+      sig { returns(String) }
+      def resolved_copy_error_text
+        @copy_error_text || t_default(:copy_failed, default: "Copy failed")
+      end
+
+      sig { returns(String) }
+      def copy_aria_label
+        t_default(:copy_aria_label, default: "Copy")
+      end
     end
   end
 end