hakumi_components 0.1.17.pre → 0.1.19.pre

data/app/components/hakumi_components/tree/node.rb

@@ -0,0 +1,276 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Tree
+    class Node
+      extend T::Sig
+
+      TreeScalar = T.type_alias { T.nilable(Types::ValidationPrimitive) }
+      TreeIcon = T.type_alias { T.nilable(Types::HtmlKey) }
+      InputKey = T.type_alias { Types::HtmlKey }
+      RawRecord = T.type_alias { T::Hash[InputKey, T.untyped] }
+      RawChildren = T.type_alias { T::Array[T.any(Node, RawInput)] }
+      RawValue = T.type_alias { T.nilable(T.any(TreeScalar, T::Array[T.untyped], RawRecord)) }
+      RawInput = T.type_alias { T::Hash[Types::HtmlKey, RawValue] }
+
+      sig do
+        params(
+          key: String,
+          title: String,
+          children: T::Array[Node],
+          disabled: T::Boolean,
+          selectable: T::Boolean,
+          checkable: T::Boolean,
+          disable_checkbox: T::Boolean,
+          icon: TreeIcon,
+          switcher_icon: TreeIcon,
+          async: T::Boolean,
+          loading: T::Boolean,
+          leaf: T::Boolean
+        ).void
+      end
+      def initialize(
+        key:,
+        title:,
+        children: [],
+        disabled: false,
+        selectable: true,
+        checkable: true,
+        disable_checkbox: false,
+        icon: nil,
+        switcher_icon: nil,
+        async: false,
+        loading: false,
+        leaf: false
+      )
+        @key = T.let(key, String)
+        @title = T.let(title, String)
+        @children = T.let(children, T::Array[Node])
+        @disabled = T.let(disabled, T::Boolean)
+        @selectable = T.let(selectable, T::Boolean)
+        @checkable = T.let(checkable, T::Boolean)
+        @disable_checkbox = T.let(disable_checkbox, T::Boolean)
+        @icon = T.let(icon, TreeIcon)
+        @switcher_icon = T.let(switcher_icon, TreeIcon)
+        @async = T.let(async, T::Boolean)
+        @loading = T.let(loading, T::Boolean)
+        @leaf = T.let(leaf, T::Boolean)
+      end
+
+      sig { returns(String) }
+      attr_reader :key
+
+      sig { returns(String) }
+      attr_reader :title
+
+      sig { returns(T::Array[Node]) }
+      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(TreeIcon) }
+      attr_reader :icon
+
+      sig { returns(TreeIcon) }
+      attr_reader :switcher_icon
+
+      sig { returns(T::Boolean) }
+      attr_reader :async
+
+      sig { returns(T::Boolean) }
+      attr_reader :loading
+
+      sig { returns(T::Boolean) }
+      attr_reader :leaf
+
+      sig do
+        params(
+          raw_nodes: RawChildren,
+          default_disabled: T::Boolean,
+          default_icon: TreeIcon,
+          default_switcher_icon: TreeIcon
+        ).returns(T::Array[Node])
+      end
+      def self.coerce_all(raw_nodes, default_disabled: false, default_icon: nil, default_switcher_icon: nil)
+        raw_nodes.map do |raw_node|
+          case raw_node
+          when Node
+            raw_node.with_defaults(
+              default_disabled: default_disabled,
+              default_icon: default_icon,
+              default_switcher_icon: default_switcher_icon
+            )
+          else
+            from_raw(
+              raw_node,
+              default_disabled: default_disabled,
+              default_icon: default_icon,
+              default_switcher_icon: default_switcher_icon
+            )
+          end
+        end
+      end
+
+      sig do
+        params(
+          default_disabled: T::Boolean,
+          default_icon: TreeIcon,
+          default_switcher_icon: TreeIcon
+        ).returns(Node)
+      end
+      def with_defaults(default_disabled: false, default_icon: nil, default_switcher_icon: nil)
+        Node.new(
+          key: @key,
+          title: @title,
+          children: @children.map do |child|
+            child.with_defaults(
+              default_disabled: default_disabled,
+              default_icon: default_icon,
+              default_switcher_icon: default_switcher_icon
+            )
+          end,
+          disabled: default_disabled || @disabled,
+          selectable: @selectable,
+          checkable: @checkable,
+          disable_checkbox: @disable_checkbox,
+          icon: @icon || default_icon,
+          switcher_icon: @switcher_icon || default_switcher_icon,
+          async: @async,
+          loading: @loading,
+          leaf: @leaf
+        )
+      end
+
+      class << self
+        extend T::Sig
+
+        private
+
+        sig do
+          params(
+            raw_node: RawInput,
+            default_disabled: T::Boolean,
+            default_icon: TreeIcon,
+            default_switcher_icon: TreeIcon
+          ).returns(Node)
+        end
+        def from_raw(raw_node, default_disabled:, default_icon:, default_switcher_icon:)
+          key = fetch_string(raw_node, :key) || fetch_string(raw_node, "key") || "node"
+          title = fetch_string(raw_node, :title) || fetch_string(raw_node, "title") || key
+          async = fetch_boolean(raw_node, :async) || fetch_boolean(raw_node, "async") || false
+          children = coerce_all(
+            fetch_children(raw_node),
+            default_disabled: default_disabled,
+            default_icon: default_icon,
+            default_switcher_icon: default_switcher_icon
+          )
+          explicit_leaf = fetch_boolean(raw_node, :is_leaf)
+          explicit_leaf = fetch_boolean(raw_node, "is_leaf") if explicit_leaf.nil?
+          leaf = explicit_leaf.nil? ? children.empty? && !async : explicit_leaf
+
+          Node.new(
+            key: key,
+            title: title,
+            children: children,
+            disabled: default_disabled || fetch_boolean(raw_node, :disabled) || fetch_boolean(raw_node, "disabled") || false,
+            selectable: fetch_optional_boolean(raw_node, :selectable, default: true),
+            checkable: fetch_optional_boolean(raw_node, :checkable, default: true),
+            disable_checkbox: fetch_boolean(raw_node, :disable_checkbox) || fetch_boolean(raw_node, "disable_checkbox") || false,
+            icon: fetch_symbol_or_string(raw_node, :icon) || fetch_symbol_or_string(raw_node, "icon") || default_icon,
+            switcher_icon: fetch_symbol_or_string(raw_node, :switcher_icon) || fetch_symbol_or_string(raw_node, "switcher_icon") || default_switcher_icon,
+            async: async,
+            loading: fetch_boolean(raw_node, :loading) || fetch_boolean(raw_node, "loading") || false,
+            leaf: leaf
+          )
+        end
+
+        sig { params(raw_node: RawInput, key: InputKey).returns(RawValue) }
+        def fetch_raw(raw_node, key)
+          raw_node[key]
+        end
+
+        sig { params(raw_node: RawInput, key: InputKey).returns(T.nilable(String)) }
+        def fetch_string(raw_node, key)
+          value = fetch_raw(raw_node, key)
+          case value
+          when String
+            value
+          when Symbol, Numeric
+            value.to_s
+          else
+            nil
+          end
+        end
+
+        sig { params(raw_node: RawInput, key: Types::HtmlKey).returns(TreeIcon) }
+        def fetch_symbol_or_string(raw_node, key)
+          value = fetch_raw(raw_node, key)
+          case value
+          when String, Symbol
+            value
+          else
+            nil
+          end
+        end
+
+        sig { params(raw_node: RawInput, key: InputKey).returns(T.nilable(T::Boolean)) }
+        def fetch_boolean(raw_node, key)
+          value = fetch_raw(raw_node, key)
+          case value
+          when nil
+            nil
+          when TrueClass
+            true
+          when FalseClass
+            false
+          when String, Symbol, Numeric
+            ActiveModel::Type::Boolean.new.cast(value)
+          else
+            nil
+          end
+        end
+
+        sig { params(raw_node: RawInput, key: InputKey, default: T::Boolean).returns(T::Boolean) }
+        def fetch_optional_boolean(raw_node, key, default:)
+          value = fetch_boolean(raw_node, key)
+          return value unless value.nil?
+
+          alternate_key = key.is_a?(String) ? key.to_sym : key.to_s
+          alternate_value = fetch_boolean(raw_node, alternate_key)
+          alternate_value.nil? ? default : alternate_value
+        end
+
+        sig { params(raw_node: RawInput).returns(RawChildren) }
+        def fetch_children(raw_node)
+          value = fetch_raw(raw_node, :children) || fetch_raw(raw_node, "children")
+          case value
+          when Array
+            children = T.let([], RawChildren)
+            value.each do |entry|
+              case entry
+              when Node
+                children << entry
+              when Hash
+                children << entry
+              end
+            end
+            children
+          else
+            []
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,18 +1,18 @@
 <% 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 Hakumi::Icon::Component.new(name: prefix_icon) %>
+            <%= render HakumiComponents::Icon::Component.new(name: prefix_icon) %>
           <% else %>
             <%= prefix %>
           <% end %>
@@ -25,39 +25,53 @@
         <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;' %>">
-        <%= render Hakumi::Icon::Component.new(name: :close_circle, theme: :filled) %>
+            style="<%= value? ? '' : 'display: none;' %>">
+        <%= render HakumiComponents::Icon::Component.new(name: :close_circle, theme: :filled) %>
       </span>
     <% end %>
 
     <span class="hakumi-tree-select-arrow">
-      <%= render Hakumi::Icon::Component.new(name: :down) %>
+      <%= render HakumiComponents::Icon::Component.new(name: :down) %>
     </span>
 
     <div class="hakumi-tree-select-dropdown hakumi-tree-select-dropdown-hidden" data-hakumi--tree-select-target="dropdown">
       <% if empty_options? %>
-        <%= render Hakumi::Empty::Component.new(description: "No Data") %>
+        <%= render HakumiComponents::Empty::Component.new(description: "No Data") %>
       <% else %>
-        <%= render Hakumi::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

@@ -0,0 +1,270 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module TreeSelect
+    class Component < HakumiComponents::BaseComponent
+      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: nil,
+        multiple: false,
+        tree_checkable: false,
+        show_search: false,
+        tree_default_expand_all: false,
+        tree_selectable_leaf_only: false,
+        disabled: false,
+        allow_clear: false,
+        size: :default,
+        variant: :default,
+        status: nil,
+        max_count: nil,
+        prefix: nil,
+        prefix_icon: nil,
+        label: nil,
+        caption: nil,
+        rules: nil,
+        errors: [],
+        standalone: true,
+        required: false,
+        **html_options
+      )
+        @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
+        @tree_default_expand_all = tree_default_expand_all
+        @tree_selectable_leaf_only = tree_selectable_leaf_only
+        @disabled = disabled
+        @allow_clear = allow_clear
+        @size = size
+        @variant = variant
+        @status = status
+        @max_count = max_count
+        @prefix = prefix
+        @prefix_icon = prefix_icon
+        @label = label
+        @caption = caption
+        @rules = T.let(rules, T.nilable(T::Array[Types::ValidationRule]))
+        @errors = T.let(errors, Types::FormFieldErrors)
+        @standalone = standalone
+        @required = required
+        @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(Types::Renderable) }
+      attr_reader :prefix
+
+      sig { returns(T.nilable(Types::StringOrSymbol)) }
+      attr_reader :prefix_icon
+
+      sig { returns(Types::HtmlAttributes) }
+      def wrapper_attributes
+        data_attrs = T.let({
+          controller: "hakumi--tree-select",
+          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
+
+        base_attrs = {
+          class: wrapper_classes,
+          data: data_attrs
+        }
+
+        merge_attributes(base_attrs, selection_control_html_options_without_class)
+      end
+
+      sig { returns(T::Boolean) }
+      def prefix?
+        value_present?(@prefix) || !@prefix_icon.nil?
+      end
+
+      sig { returns(T::Boolean) }
+      def empty_options?
+        options.empty?
+      end
+
+      sig { returns(T::Boolean) }
+      def borderless?
+        @variant == :borderless
+      end
+
+      sig { returns(T.nilable(Symbol)) }
+      def effective_status
+        return :error if error?
+
+        @status
+      end
+
+      sig { returns(T.nilable(String)) }
+      def input_value
+        if multi_value?
+          selected_keys.to_json
+        else
+          selected_keys.first
+        end
+      end
+
+      sig { returns(T.nilable(String)) }
+      def display_label
+        labels = selected_labels
+        return nil if labels.empty?
+
+        labels.join(", ")
+      end
+
+      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: selection_control_size == :large,
+            sm: selection_control_size == :small,
+            borderless: borderless?,
+            disabled: selection_control_disabled,
+            "allow-clear": selection_control_allow_clear,
+            multiple: @multiple,
+            checkable: @tree_checkable,
+            "has-value": value?,
+            "status-error": effective_status == :error,
+            "status-warning": effective_status == :warning
+          },
+          [ selection_control_html_class_name ]
+        ).split.uniq.join(" ")
+      end
+
+      sig { returns(T::Array[HakumiComponents::SelectionControl::TreeNode]) }
+      def normalized_options
+        options
+      end
+
+      sig { returns(T::Array[String]) }
+      def selected_keys
+        keys = if multi_value?
+          Array(selection_control_value)
+        elsif selection_control_has_value?
+          [ selection_control_value ]
+        else
+          []
+        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?
+
+        label_map = build_label_map(normalized_options)
+        selected_keys.map { |key| label_map[key] || key }
+      end
+
+      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
+
+      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
+    end
+  end
+end