hakumi_components 0.1.17.pre → 0.1.19.pre

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

@@ -0,0 +1,342 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Tree
+    class Component < HakumiComponents::BaseComponent
+      extend T::Sig
+
+      include Concerns::NodeRendering
+
+      DEFAULT_INDENT = T.let(24, Integer)
+      RawNode = T.type_alias { HakumiComponents::Tree::Node::RawInput }
+      NodeInput = T.type_alias { T.any(HakumiComponents::Tree::Node, RawNode) }
+      NodeKey = T.type_alias { Types::ValidationComparable }
+      NodeKeyList = T.type_alias { T::Array[NodeKey] }
+      IconInput = T.type_alias { BaseComponent::SymbolInput }
+      HeightInput = T.type_alias { T.nilable(BaseComponent::DimensionInput) }
+      ControllerLocalValue = T.type_alias { T.nilable(T.any(Types::HtmlPrimitive, T::Array[HakumiComponents::Tree::Node], NodeKeyList)) }
+
+      class NodeState < T::Struct
+        const :expanded, T::Boolean
+        const :selected, T::Boolean
+        const :checked, T::Boolean
+        const :half_checked, T::Boolean
+      end
+
+      sig do
+        params(params: BaseComponent::ControllerOptions).returns(T::Hash[Symbol, ControllerLocalValue])
+      end
+      def self.extract_controller_locals(params)
+        raw_nodes = parse_raw_nodes(html_param(params, :nodes) || html_param(params, :tree_data))
+
+        {
+          nodes: HakumiComponents::Tree::Node.coerce_all(raw_nodes),
+          checkable: boolean_html_param(html_param(params, :checkable)) == true,
+          selectable: boolean_html_param(html_param(params, :selectable)) != false,
+          disabled: boolean_html_param(html_param(params, :disabled)) == true,
+          default_expand_keys: parse_json_array(html_param(params, :default_expand_keys)),
+          default_selected_keys: parse_json_array(html_param(params, :default_selected_keys)),
+          default_checked_keys: parse_json_array(html_param(params, :default_checked_keys)),
+          expanded_keys: parse_json_array(html_param(params, :expanded_keys), allow_nil: true),
+          selected_keys: parse_json_array(html_param(params, :selected_keys), allow_nil: true),
+          checked_keys: parse_json_array(html_param(params, :checked_keys), allow_nil: true),
+          show_line: boolean_html_param(html_param(params, :show_line)) == true,
+          switcher_icon: symbol_html_param(html_param(params, :switcher_icon)),
+          icon: symbol_html_param(html_param(params, :icon)),
+          directory: boolean_html_param(html_param(params, :directory)) == true,
+          multiple: boolean_html_param(html_param(params, :multiple)) == true,
+          draggable: boolean_html_param(html_param(params, :draggable)) == true,
+          block_node: boolean_html_param(html_param(params, :block_node)) == true,
+          searchable: boolean_html_param(html_param(params, :searchable)) == true,
+          height: html_primitive_param(html_param(params, :height)),
+          check_strictly: boolean_html_param(html_param(params, :check_strictly)) == true
+        }
+      end
+
+      sig do
+        params(
+          nodes: T::Array[NodeInput],
+          checkable: T::Boolean,
+          selectable: T::Boolean,
+          disabled: T::Boolean,
+          default_expand_keys: NodeKeyList,
+          default_selected_keys: NodeKeyList,
+          default_checked_keys: NodeKeyList,
+          expanded_keys: T.nilable(NodeKeyList),
+          selected_keys: T.nilable(NodeKeyList),
+          checked_keys: T.nilable(NodeKeyList),
+          show_line: T::Boolean,
+          switcher_icon: IconInput,
+          icon: IconInput,
+          directory: T::Boolean,
+          multiple: T::Boolean,
+          draggable: T::Boolean,
+          block_node: T::Boolean,
+          searchable: T::Boolean,
+          search_placeholder: T.nilable(String),
+          height: HeightInput,
+          check_strictly: T::Boolean,
+          indent: Integer,
+          html_options: Types::HtmlAttributeValue
+        ).void
+      end
+      def initialize(
+        nodes:,
+        checkable: false,
+        selectable: true,
+        disabled: false,
+        default_expand_keys: [],
+        default_selected_keys: [],
+        default_checked_keys: [],
+        expanded_keys: nil,
+        selected_keys: nil,
+        checked_keys: nil,
+        show_line: false,
+        switcher_icon: nil,
+        icon: nil,
+        directory: false,
+        multiple: false,
+        draggable: false,
+        block_node: false,
+        searchable: false,
+        search_placeholder: nil,
+        height: nil,
+        check_strictly: false,
+        indent: DEFAULT_INDENT,
+        **html_options
+      )
+        @checkable = T.let(checkable, T::Boolean)
+        @selectable = T.let(selectable, T::Boolean)
+        @disabled = T.let(disabled, T::Boolean)
+        @default_expand_keys = T.let(default_expand_keys.map(&:to_s), T::Array[String])
+        @default_selected_keys = T.let(default_selected_keys.map(&:to_s), T::Array[String])
+        @default_checked_keys = T.let(default_checked_keys.map(&:to_s), T::Array[String])
+        @expanded_keys = T.let(expanded_keys&.map(&:to_s), T.nilable(T::Array[String]))
+        @selected_keys = T.let(selected_keys&.map(&:to_s), T.nilable(T::Array[String]))
+        @checked_keys = T.let(checked_keys&.map(&:to_s), T.nilable(T::Array[String]))
+        @show_line = T.let(show_line, T::Boolean)
+        @switcher_icon = T.let(switcher_icon, IconInput)
+        @icon = T.let(icon, IconInput)
+        @directory = T.let(directory, T::Boolean)
+        @multiple = T.let(multiple, T::Boolean)
+        @draggable = T.let(draggable, T::Boolean)
+        @block_node = T.let(block_node, T::Boolean)
+        @searchable = T.let(searchable, T::Boolean)
+        @search_placeholder = T.let(search_placeholder || t_default(:search_placeholder, default: "Search"), String)
+        @height = T.let(height, HeightInput)
+        @check_strictly = T.let(check_strictly, T::Boolean)
+        @indent = T.let(indent, Integer)
+        @html_options = T.let(html_options, Types::HtmlAttributes)
+        @normalized_nodes = T.let(
+          HakumiComponents::Tree::Node.coerce_all(
+            nodes,
+            default_disabled: @disabled,
+            default_icon: @icon,
+            default_switcher_icon: @switcher_icon
+          ),
+          T::Array[HakumiComponents::Tree::Node]
+        )
+
+        validate_props!
+      end
+
+      sig { returns(T::Array[HakumiComponents::Tree::Node]) }
+      attr_reader :normalized_nodes
+
+      sig { returns(Types::HtmlAttributes) }
+      def wrapper_attributes
+        merge_attributes(
+          {
+            class: wrapper_classes,
+            data: data_attributes
+          },
+          @html_options
+        )
+      end
+
+      sig { returns(Types::HtmlAttributes) }
+      def list_attributes
+        attrs = T.let(
+          {
+            class: list_classes,
+            role: "tree",
+            data: { hakumi__tree_target: "list" }
+          },
+          Types::HtmlAttributes
+        )
+        attrs[:style] = "max-height: #{@height}px;" if @height
+        attrs
+      end
+
+      sig { returns(T::Boolean) }
+      def searchable?
+        @searchable
+      end
+
+      sig { returns(String) }
+      def search_placeholder
+        @search_placeholder
+      end
+
+      private
+
+      sig { returns(String) }
+      def wrapper_classes
+        component_classes(
+          "tree",
+          {
+            checkable: @checkable,
+            "show-line": @show_line,
+            directory: @directory,
+            draggable: @draggable,
+            "block-node": @block_node,
+            disabled: @disabled,
+            searchable: @searchable,
+            virtual: !@height.nil?
+          },
+          @html_options
+        )
+      end
+
+      sig { returns(String) }
+      def list_classes
+        class_names("tree-list", { virtual: !@height.nil? })
+      end
+
+      sig { returns(Types::DataAttributes) }
+      def data_attributes
+        data = T.let(
+          {
+            controller: "hakumi--tree",
+            hakumi__tree_checkable_value: @checkable,
+            hakumi__tree_selectable_value: @selectable,
+            hakumi__tree_disabled_value: @disabled,
+            hakumi__tree_default_expand_keys_value: @default_expand_keys.to_json,
+            hakumi__tree_default_selected_keys_value: @default_selected_keys.to_json,
+            hakumi__tree_default_checked_keys_value: @default_checked_keys.to_json,
+            hakumi__tree_show_line_value: @show_line,
+            hakumi__tree_switcher_icon_value: @switcher_icon&.to_s,
+            hakumi__tree_icon_value: @icon&.to_s,
+            hakumi__tree_directory_value: @directory,
+            hakumi__tree_multiple_value: @multiple,
+            hakumi__tree_draggable_value: @draggable,
+            hakumi__tree_block_node_value: @block_node,
+            hakumi__tree_searchable_value: @searchable,
+            hakumi__tree_height_value: @height,
+            hakumi__tree_check_strictly_value: @check_strictly
+          },
+          Types::DataAttributes
+        )
+        data[:hakumi__tree_expanded_keys_value] = @expanded_keys.to_json if @expanded_keys
+        data[:hakumi__tree_selected_keys_value] = @selected_keys.to_json if @selected_keys
+        data[:hakumi__tree_checked_keys_value] = @checked_keys.to_json if @checked_keys
+        data
+      end
+
+      sig { void }
+      def validate_props!
+        raise ArgumentError, "indent must be positive" unless @indent.positive?
+      end
+
+      sig { override.returns(T::Boolean) }
+      def tree_checkable?
+        @checkable
+      end
+
+      sig { override.returns(T::Boolean) }
+      def tree_show_line?
+        @show_line
+      end
+
+      sig { override.returns(IconInput) }
+      def tree_switcher_icon
+        @switcher_icon
+      end
+
+      sig { override.returns(IconInput) }
+      def tree_icon
+        @icon
+      end
+
+      sig { override.returns(T::Boolean) }
+      def tree_directory?
+        @directory
+      end
+
+      sig { params(value: Types::HtmlAttributeValue).returns(T::Array[RawNode]) }
+      def self.parse_raw_nodes(value)
+        return [] if value.nil?
+
+        array = if value.is_a?(Array)
+          value
+        elsif value.is_a?(String)
+          parsed = JSON.parse(value)
+          parsed.is_a?(Array) ? parsed : []
+        else
+          []
+        end
+
+        array.filter_map do |entry|
+          next unless entry.is_a?(Hash)
+          typed_entry = T.let({}, RawNode)
+          entry.each do |key, item|
+            next unless key.is_a?(String) || key.is_a?(Symbol)
+            next unless item.nil? || item.is_a?(String) || item.is_a?(Symbol) || item.is_a?(Numeric) || item == true || item == false || item.is_a?(Array) || item.is_a?(Hash)
+
+            typed_entry[key] = item
+          end
+          typed_entry
+        end
+      rescue JSON::ParserError
+        []
+      end
+
+      sig { params(value: Types::HtmlAttributeValue, allow_nil: T::Boolean).returns(T.nilable(NodeKeyList)) }
+      def self.parse_json_array(value, allow_nil: false)
+        return nil if allow_nil && value.nil?
+        return [] if value.nil?
+
+        array = if value.is_a?(Array)
+          value
+        elsif value.is_a?(String)
+          parsed = JSON.parse(value)
+          parsed.is_a?(Array) ? parsed : []
+        else
+          []
+        end
+
+        array.filter_map do |entry|
+          case entry
+          when String, Symbol, Numeric
+            entry
+          else
+            nil
+          end
+        end
+      rescue JSON::ParserError
+        []
+      end
+
+      sig { override.params(key: String).returns(T::Boolean) }
+      def expanded?(key)
+        (@expanded_keys || @default_expand_keys).include?(key)
+      end
+
+      sig { override.params(key: String).returns(T::Boolean) }
+      def selected?(key)
+        (@selected_keys || @default_selected_keys).include?(key)
+      end
+
+      sig { override.params(key: String).returns(T::Boolean) }
+      def checked?(key)
+        (@checked_keys || @default_checked_keys).include?(key)
+      end
+
+      sig { override.params(_key: String).returns(T::Boolean) }
+      def half_checked?(_key)
+        false
+      end
+    end
+  end
+end

data/app/components/hakumi_components/tree/concerns/node_rendering.rb

@@ -0,0 +1,365 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Tree
+    module Concerns
+      module NodeRendering
+        extend ActiveSupport::Concern
+        extend T::Sig
+        extend T::Helpers
+
+        abstract!
+
+        requires_ancestor { HakumiComponents::BaseComponent }
+
+        NodeState = T.type_alias { HakumiComponents::Tree::Component::NodeState }
+        IconInput = T.type_alias { HakumiComponents::BaseComponent::SymbolInput }
+        AriaAttributes = T.type_alias { T::Hash[Symbol, Types::HtmlPrimitive] }
+
+        sig { returns(ActiveSupport::SafeBuffer) }
+        def render_node_template
+          switcher_content = render_switcher_icon_markup(resolve_switcher_config(tree_switcher_icon))
+          switcher = renderer.content_tag(:button, type: "button", class: "hakumi-tree-switcher", data: { action: "click->hakumi--tree#toggle" }) do
+            switcher_content
+          end
+          checkbox = if tree_checkable?
+            renderer.content_tag(:button, type: "button", class: "hakumi-tree-checkbox", data: { action: "click->hakumi--tree#toggleCheck" }) do
+              renderer.content_tag(:span, "", class: "hakumi-tree-checkbox-inner")
+            end
+          end
+          icon = renderer.content_tag(:span, default_icon_markup, class: "hakumi-tree-icon", style: default_icon_style)
+          title = renderer.content_tag(:button, type: "button", class: "hakumi-tree-title", data: { action: "click->hakumi--tree#select" }) do
+            renderer.content_tag(:span, "", class: "hakumi-tree-title-text")
+          end
+          indent = renderer.content_tag(:span, "", class: "hakumi-tree-indent", data: { hakumi__tree_target: "indent" })
+          content_inner = renderer.safe_join([ checkbox, icon, title ].compact)
+          content_wrapper = renderer.content_tag(:div, content_inner, class: "hakumi-tree-node-content-wrapper", data: { hakumi__tree_target: "content", action: "click->hakumi--tree#select" })
+          row = renderer.content_tag(:div, renderer.safe_join([ indent, switcher, content_wrapper ]), class: "hakumi-tree-node-row")
+          children = renderer.content_tag(:div, "", class: "hakumi-tree-children", role: "group", data: { hakumi__tree_target: "children" })
+
+          renderer.content_tag(:div, renderer.safe_join([ row, children ]), class: "hakumi-tree-node", role: "treeitem", tabindex: "-1", data: { hakumi__tree_target: "node" })
+        end
+
+        sig { params(level_mask: T::Array[T::Boolean]).returns(ActiveSupport::SafeBuffer) }
+        def render_indent(level_mask)
+          inner_html = level_mask.inject(ActiveSupport::SafeBuffer.new) do |buffer, has_line|
+            classes = [ "hakumi-tree-indent-unit" ]
+            classes << "hakumi-tree-indent-unit-active" if has_line
+            buffer << renderer.content_tag(:span, "", class: classes)
+          end
+
+          renderer.content_tag(:span, inner_html, class: "hakumi-tree-indent", aria: { hidden: true })
+        end
+
+        sig do
+          params(
+            nodes: T::Array[HakumiComponents::Tree::Node],
+            level_mask: T::Array[T::Boolean],
+            level: Integer,
+            parent_key: T.nilable(String)
+          ).returns(ActiveSupport::SafeBuffer)
+        end
+        def render_nodes(nodes, level_mask: [], level: 0, parent_key: nil)
+          renderer.safe_join(nodes.map.with_index do |node, index|
+            has_next = index < nodes.size - 1
+            render_node(node, index: index, total: nodes.size, level_mask: level_mask, has_next: has_next, level: level, parent_key: parent_key)
+          end)
+        end
+
+        private
+
+        sig { abstract.returns(T::Boolean) }
+        def tree_checkable?; end
+
+        sig { abstract.returns(T::Boolean) }
+        def tree_show_line?; end
+
+        sig { abstract.returns(IconInput) }
+        def tree_switcher_icon; end
+
+        sig { abstract.returns(IconInput) }
+        def tree_icon; end
+
+        sig { abstract.returns(T::Boolean) }
+        def tree_directory?; end
+
+        sig { abstract.params(key: String).returns(T::Boolean) }
+        def expanded?(key); end
+
+        sig { abstract.params(key: String).returns(T::Boolean) }
+        def selected?(key); end
+
+        sig { abstract.params(key: String).returns(T::Boolean) }
+        def checked?(key); end
+
+        sig { abstract.params(key: String).returns(T::Boolean) }
+        def half_checked?(key); end
+
+        sig { returns(T.untyped) }
+        def renderer
+          T.unsafe(self)
+        end
+
+        sig do
+          params(
+            node: HakumiComponents::Tree::Node,
+            index: Integer,
+            total: Integer,
+            level_mask: T::Array[T::Boolean],
+            has_next: T::Boolean,
+            level: Integer,
+            parent_key: T.nilable(String)
+          ).returns(ActiveSupport::SafeBuffer)
+        end
+        def render_node(node, index:, total:, level_mask:, has_next:, level:, parent_key:)
+          state = node_state(node)
+
+          attrs = node_attributes(
+            node,
+            state,
+            index: index,
+            total: total,
+            has_next: has_next,
+            level: level,
+            parent_key: parent_key
+          )
+
+          renderer.content_tag(:div, attrs) do
+            renderer.safe_join([
+              render_node_row(node, state, level_mask),
+              render_node_children(node, level_mask: level_mask + [ has_next ], level: level + 1)
+            ].compact)
+          end
+        end
+
+        sig do
+          params(
+            node: HakumiComponents::Tree::Node,
+            state: NodeState,
+            index: Integer,
+            total: Integer,
+            has_next: T::Boolean,
+            level: Integer,
+            parent_key: T.nilable(String)
+          ).returns(Types::HtmlAttributes)
+        end
+        def node_attributes(node, state, index:, total:, has_next:, level:, parent_key:)
+          T.let(
+            {
+              class: node_classes(node, state),
+              role: "treeitem",
+              tabindex: -1,
+              data: node_data(node, index: index, total: total, has_next: has_next, level: level, parent_key: parent_key),
+              aria: node_aria(node, state)
+            },
+            Types::HtmlAttributes
+          )
+        end
+
+        sig do
+          params(
+            node: HakumiComponents::Tree::Node,
+            state: NodeState,
+            level_mask: T::Array[T::Boolean]
+          ).returns(ActiveSupport::SafeBuffer)
+        end
+        def render_node_row(node, state, level_mask)
+          renderer.content_tag(:div, class: "hakumi-tree-node-row") do
+            renderer.safe_join([
+              render_indent(level_mask),
+              render_switcher(node),
+              render_node_content_wrapper(node, state)
+            ].compact)
+          end
+        end
+
+        sig { params(node: HakumiComponents::Tree::Node).returns(NodeState) }
+        def node_state(node)
+          HakumiComponents::Tree::Component::NodeState.new(
+            expanded: expanded?(node.key),
+            selected: selected?(node.key),
+            checked: checked?(node.key),
+            half_checked: half_checked?(node.key)
+          )
+        end
+
+        sig { params(node: HakumiComponents::Tree::Node, state: NodeState).returns(String) }
+        def node_classes(node, state)
+          renderer.class_names(
+            "tree-node",
+            {
+              disabled: node.disabled,
+              selected: state.selected,
+              checked: state.checked,
+              "half-checked": state.half_checked,
+              expanded: state.expanded,
+              leaf: node.leaf,
+              async: node.async,
+              loading: node.loading
+            }
+          )
+        end
+
+        sig do
+          params(
+            node: HakumiComponents::Tree::Node,
+            index: Integer,
+            total: Integer,
+            has_next: T::Boolean,
+            level: Integer,
+            parent_key: T.nilable(String)
+          ).returns(Types::DataAttributes)
+        end
+        def node_data(node, index:, total:, has_next:, level:, parent_key:)
+          {
+            hakumi__tree_target: "node",
+            key: node.key,
+            parent_key: parent_key,
+            level: level,
+            title: node.title,
+            selectable: node.selectable,
+            checkable: node.checkable,
+            disabled: node.disabled,
+            leaf: node.leaf,
+            async: node.async,
+            loading: node.loading,
+            index: index,
+            total: total,
+            has_next: has_next
+          }
+        end
+
+        sig { params(node: HakumiComponents::Tree::Node, state: NodeState).returns(AriaAttributes) }
+        def node_aria(node, state)
+          aria = T.let({ selected: state.selected }, AriaAttributes)
+          aria[:expanded] = state.expanded unless node.leaf
+          aria
+        end
+
+        sig { params(node: HakumiComponents::Tree::Node, state: NodeState).returns(ActiveSupport::SafeBuffer) }
+        def render_node_content_wrapper(node, state)
+          renderer.content_tag(:div, class: "hakumi-tree-node-content-wrapper", data: { hakumi__tree_target: "content", action: "click->hakumi--tree#select" }) do
+            renderer.safe_join([ render_checkbox(node, state), render_icon(node), render_title(node) ].compact)
+          end
+        end
+
+        sig { params(node: HakumiComponents::Tree::Node).returns(ActiveSupport::SafeBuffer) }
+        def render_switcher(node)
+          switcher_conf = resolve_switcher_config(node.switcher_icon)
+          renderer.content_tag(:button,
+            type: "button",
+            class: switcher_classes(node.leaf),
+            aria: { label: node.leaf ? "Leaf" : "Toggle" },
+            data: { action: (node.leaf ? nil : "click->hakumi--tree#toggle"), hakumi__tree_target: "switcher", key: node.key }.compact
+          ) do
+            if node.leaf
+              renderer.content_tag(:span, "", class: "hakumi-tree-switcher-noop")
+            else
+              render_switcher_icon_markup(switcher_conf)
+            end
+          end
+        end
+
+        sig { params(icon_or_conf: IconInput).returns(T::Hash[Symbol, Symbol]) }
+        def resolve_switcher_config(icon_or_conf)
+          candidate = icon_or_conf || tree_switcher_icon
+          if candidate
+            case candidate.to_sym
+            when :plus, :plus_square, :plus_circle
+              suffix = candidate.to_s.gsub("plus", "")
+              { collapse: candidate.to_sym, expand: "minus#{suffix}".to_sym }
+            when :folder, :folder_open
+              { collapse: :folder, expand: :folder_open }
+            else
+              { default: candidate.to_sym }
+            end
+          elsif tree_show_line?
+            { collapse: :plus_square, expand: :minus_square }
+          else
+            { default: :caret_right }
+          end
+        end
+
+        sig { params(node: HakumiComponents::Tree::Node, state: NodeState).returns(T.nilable(ActiveSupport::SafeBuffer)) }
+        def render_checkbox(node, state)
+          return nil unless tree_checkable? && node.checkable
+
+          renderer.content_tag(:button,
+            type: "button",
+            class: "hakumi-tree-checkbox",
+            aria: { checked: state.checked },
+            data: { action: "click->hakumi--tree#toggleCheck", hakumi__tree_target: "checkbox", key: node.key, disabled: node.disable_checkbox }
+          ) do
+            renderer.content_tag(:span, "", class: "hakumi-tree-checkbox-inner")
+          end
+        end
+
+        sig { params(node: HakumiComponents::Tree::Node).returns(T.nilable(ActiveSupport::SafeBuffer)) }
+        def render_icon(node)
+          icon_name = node.icon
+          icon_name = node.leaf ? :file : :folder if icon_name.nil? && tree_directory?
+          return nil if icon_name.nil?
+
+          renderer.content_tag(:span, class: "hakumi-tree-icon") do
+            renderer.render HakumiComponents::Icon::Component.new(name: icon_name)
+          end
+        end
+
+        sig { params(node: HakumiComponents::Tree::Node).returns(ActiveSupport::SafeBuffer) }
+        def render_title(node)
+          renderer.content_tag(:button,
+            type: "button",
+            class: "hakumi-tree-title",
+            data: { action: "click->hakumi--tree#select", hakumi__tree_target: "title", key: node.key }
+          ) do
+            renderer.content_tag(:span, node.title, class: "hakumi-tree-title-text", data: { title: node.title })
+          end
+        end
+
+        sig { params(node: HakumiComponents::Tree::Node, level_mask: T::Array[T::Boolean], level: Integer).returns(T.nilable(ActiveSupport::SafeBuffer)) }
+        def render_node_children(node, level_mask: [], level: 0)
+          return nil if node.children.empty?
+
+          renderer.content_tag(:div, class: "hakumi-tree-children", role: "group", data: { hakumi__tree_target: "children" }) do
+            render_nodes(node.children, level_mask: level_mask, level: level, parent_key: node.key)
+          end
+        end
+
+        sig { params(is_leaf: T::Boolean).returns(String) }
+        def switcher_classes(is_leaf)
+          renderer.class_names("tree-switcher", { leaf: is_leaf })
+        end
+
+        sig { params(config: T::Hash[Symbol, Symbol]).returns(ActiveSupport::SafeBuffer) }
+        def render_switcher_icon_markup(config)
+          if config[:default]
+            renderer.content_tag(:span, class: "hakumi-tree-switcher-icon") do
+              renderer.render HakumiComponents::Icon::Component.new(name: config[:default])
+            end
+          else
+            renderer.content_tag(:span, class: "hakumi-tree-switcher-icon hakumi-tree-switcher-dual") do
+              renderer.safe_join([
+                renderer.content_tag(:span, class: "hakumi-tree-icon-collapse") { renderer.render HakumiComponents::Icon::Component.new(name: config.fetch(:collapse)) },
+                renderer.content_tag(:span, class: "hakumi-tree-icon-expand") { renderer.render HakumiComponents::Icon::Component.new(name: config.fetch(:expand)) }
+              ])
+            end
+          end
+        end
+
+        sig { returns(T.nilable(ActiveSupport::SafeBuffer)) }
+        def default_icon_markup
+          icon = tree_icon
+          return nil if icon.nil?
+
+          renderer.render HakumiComponents::Icon::Component.new(name: icon)
+        end
+
+        sig { returns(T.nilable(String)) }
+        def default_icon_style
+          tree_icon.nil? ? "display: none" : nil
+        end
+      end
+    end
+  end
+end