hakumi_components 0.1.18.pre → 0.1.19.pre

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

@@ -1,35 +1,86 @@
+# typed: strict
 # frozen_string_literal: true
 
 module HakumiComponents
   module Tree
     class Component < HakumiComponents::BaseComponent
-      DEFAULT_INDENT = 24
+      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: parse_nodes(params[:nodes]),
-          checkable: boolean_param(params[:checkable]),
-          selectable: boolean_param(params[:selectable], default: true),
-          disabled: boolean_param(params[:disabled]),
-          default_expand_keys: parse_json_array(params[:default_expand_keys]),
-          default_selected_keys: parse_json_array(params[:default_selected_keys]),
-          default_checked_keys: parse_json_array(params[:default_checked_keys]),
-          expanded_keys: parse_json_array(params[:expanded_keys], allow_nil: true),
-          selected_keys: parse_json_array(params[:selected_keys], allow_nil: true),
-          checked_keys: parse_json_array(params[:checked_keys], allow_nil: true),
-          show_line: boolean_param(params[:show_line]),
-          switcher_icon: params[:switcher_icon],
-          icon: params[:icon],
-          directory: boolean_param(params[:directory]),
-          multiple: boolean_param(params[:multiple]),
-          draggable: boolean_param(params[:draggable]),
-          block_node: boolean_param(params[:block_node]),
-          searchable: boolean_param(params[:searchable]),
-          height: params[:height],
-          check_strictly: boolean_param(params[:check_strictly])
+          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,
@@ -49,148 +100,90 @@ module HakumiComponents
         draggable: false,
         block_node: false,
         searchable: false,
-        search_placeholder: "Search",
+        search_placeholder: nil,
         height: nil,
         check_strictly: false,
         indent: DEFAULT_INDENT,
         **html_options
       )
-        @nodes = nodes
-        @checkable = checkable
-        @selectable = selectable
-        @disabled = disabled
-        @default_expand_keys = Array(default_expand_keys)
-        @default_selected_keys = Array(default_selected_keys)
-        @default_checked_keys = Array(default_checked_keys)
-        @expanded_keys = expanded_keys.nil? ? nil : Array(expanded_keys)
-        @selected_keys = selected_keys.nil? ? nil : Array(selected_keys)
-        @checked_keys = checked_keys.nil? ? nil : Array(checked_keys)
-        @show_line = show_line
-        @switcher_icon = switcher_icon
-        @icon = icon
-        @directory = directory
-        @multiple = multiple
-        @draggable = draggable
-        @block_node = block_node
-        @searchable = searchable
-        @search_placeholder = search_placeholder
-        @height = height
-        @check_strictly = check_strictly
-        @indent = indent
-        @html_options = 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!
-        @normalized_nodes = normalize_nodes(@nodes)
       end
 
+      sig { returns(T::Array[HakumiComponents::Tree::Node]) }
       attr_reader :normalized_nodes
 
+      sig { returns(Types::HtmlAttributes) }
       def wrapper_attributes
-        base_attrs = {
-          class: wrapper_classes,
-          data: data_attributes
-        }
-
-        merge_attributes(base_attrs, @html_options)
+        merge_attributes(
+          {
+            class: wrapper_classes,
+            data: data_attributes
+          },
+          @html_options
+        )
       end
 
+      sig { returns(Types::HtmlAttributes) }
       def list_attributes
-        attrs = {
-          class: list_classes,
-          role: "tree",
-          data: { hakumi__tree_target: "list" }
-        }
-
-        if @height.present?
-          height_value = @height.to_s
-          attrs[:style] = "max-height: #{height_value}px;"
-        end
-
+        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
 
-      def render_node_template
-        switcher_conf = if @switcher_icon.present?
-          { default: @switcher_icon }
-        elsif @show_line
-          { collapse: :plus_square, expand: :minus_square }
-        else
-          { default: :caret_right }
-        end
-
-        switcher_content = if switcher_conf[:default]
-          content_tag(:span, class: "hakumi-tree-switcher-icon") do
-            render HakumiComponents::Icon::Component.new(name: switcher_conf[:default])
-          end
-        else
-          content_tag(:span, class: "hakumi-tree-switcher-icon hakumi-tree-switcher-dual") do
-            safe_join([
-              content_tag(:span, class: "hakumi-tree-icon-collapse") { render HakumiComponents::Icon::Component.new(name: switcher_conf[:collapse]) },
-              content_tag(:span, class: "hakumi-tree-icon-expand") { render HakumiComponents::Icon::Component.new(name: switcher_conf[:expand]) }
-            ])
-          end
-        end
-
-        switcher = content_tag(:button, type: "button", class: "hakumi-tree-switcher", data: { action: "click->hakumi--tree#toggle" }) do
-          switcher_content
-        end
-
-        checkbox = if @checkable
-          content_tag(:button, type: "button", class: "hakumi-tree-checkbox", data: { action: "click->hakumi--tree#toggleCheck" }) do
-            content_tag(:span, "", class: "hakumi-tree-checkbox-inner")
-          end
-        end
-
-        # Icon handling
-        icon_content = if @icon.present?
-          render HakumiComponents::Icon::Component.new(name: @icon)
-        end
-
-        icon_style = @icon.present? ? nil : "display: none"
-        icon = content_tag(:span, icon_content, class: "hakumi-tree-icon", style: icon_style)
-
-        title = content_tag(:button, type: "button", class: "hakumi-tree-title", data: { action: "click->hakumi--tree#select" }) do
-          content_tag(:span, "", class: "hakumi-tree-title-text")
-        end
-
-        indent = content_tag(:span, "", class: "hakumi-tree-indent", data: { hakumi__tree_target: "indent" })
-
-        content_inner = safe_join([ checkbox, icon, title ].compact)
-        content_wrapper = content_tag(:div, content_inner, class: "hakumi-tree-node-content-wrapper", data: { hakumi__tree_target: "content", action: "click->hakumi--tree#select" })
-
-        row = content_tag(:div, safe_join([ indent, switcher, content_wrapper ]), class: "hakumi-tree-node-row")
-        children = content_tag(:div, "", class: "hakumi-tree-children", role: "group", data: { hakumi__tree_target: "children" })
-
-        content_tag(:div, safe_join([ row, children ]), class: "hakumi-tree-node", role: "treeitem", tabindex: "-1", data: { hakumi__tree_target: "node" })
-      end
-
-      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 << content_tag(:span, "", class: classes)
-        end
-
-        content_tag(:span, inner_html, class: "hakumi-tree-indent", aria: { hidden: true })
-      end
-
-      def render_nodes(nodes, level_mask: [])
-        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)
-        end)
-      end
+      private
 
+      sig { returns(String) }
       def wrapper_classes
-        class_names(
+        component_classes(
           "tree",
           {
             checkable: @checkable,
@@ -200,324 +193,150 @@ module HakumiComponents
             "block-node": @block_node,
             disabled: @disabled,
             searchable: @searchable,
-            virtual: @height.present?
+            virtual: !@height.nil?
           },
-          [ @html_options[:class] ]
+          @html_options
         )
       end
 
+      sig { returns(String) }
       def list_classes
-        class_names("tree-list", { virtual: @height.present? })
+        class_names("tree-list", { virtual: !@height.nil? })
       end
 
+      sig { returns(Types::DataAttributes) }
       def data_attributes
-        data = {
-          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.presence,
-          hakumi__tree_icon_value: @icon.to_s.presence,
-          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
-        }
-
+        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.compact
+        data
       end
 
+      sig { void }
       def validate_props!
-        raise ArgumentError, "nodes is required" if @nodes.nil?
-        raise ArgumentError, "nodes must be an Array" unless @nodes.is_a?(Array)
+        raise ArgumentError, "indent must be positive" unless @indent.positive?
       end
 
-      def normalize_nodes(nodes, parent_key: nil, level: 0)
-        Array(nodes).map.with_index do |node, index|
-          raise ArgumentError, "node must be a Hash" unless node.is_a?(Hash)
-
-          key = node[:key] || node["key"] || "#{parent_key || 'node'}-#{index}"
-          title = node[:title] || node["title"] || key
-          children = node[:children] || node["children"] || []
-          normalized_children = normalize_nodes(children, parent_key: key, level: level + 1)
-
-          is_leaf = if node.key?(:is_leaf) || node.key?("is_leaf")
-            node[:is_leaf] || node["is_leaf"]
-          else
-            normalized_children.empty? && !(node[:async] || node["async"])
-          end
-
-          {
-            key: key.to_s,
-            title: title,
-            children: normalized_children,
-            disabled: @disabled || node[:disabled] || node["disabled"],
-            selectable: node.key?(:selectable) ? node[:selectable] : node.fetch("selectable", true),
-            checkable: node.key?(:checkable) ? node[:checkable] : node.fetch("checkable", true),
-            disable_checkbox: node[:disable_checkbox] || node["disable_checkbox"],
-            icon: node[:icon] || node["icon"] || @icon,
-            switcher_icon: node[:switcher_icon] || node["switcher_icon"] || @switcher_icon,
-            async: node[:async] || node["async"],
-            loading: node[:loading] || node["loading"],
-            level: level,
-            parent_key: parent_key,
-            leaf: is_leaf
-          }
-        end
+      sig { override.returns(T::Boolean) }
+      def tree_checkable?
+        @checkable
       end
 
-      def render_node(node, index:, total:, level_mask:, has_next:)
-        node_attrs = {
-          class: node_classes(node),
-          role: "treeitem",
-          tabindex: -1,
-          data: node_data(node, index: index, total: total, has_next: has_next),
-          aria: node_aria(node)
-        }
-
-        content_tag(:div, node_attrs) do
-          row = content_tag(:div, class: "hakumi-tree-node-row") do
-            safe_join([
-              render_indent(level_mask),
-              render_switcher(node),
-              render_node_content_wrapper(node)
-            ].compact)
-          end
-
-          safe_join([
-            row,
-            render_node_children(node, level_mask + [ has_next ])
-          ].compact)
-        end
+      sig { override.returns(T::Boolean) }
+      def tree_show_line?
+        @show_line
       end
 
-      def node_classes(node)
-        class_names(
-          "tree-node",
-          {
-            disabled: node[:disabled],
-            selected: selected?(node[:key]),
-            checked: checked?(node[:key]),
-            "half-checked": half_checked?(node[:key]),
-            expanded: expanded?(node[:key]),
-            leaf: node[:leaf],
-            "async": node[:async],
-            loading: node[:loading]
-          }
-        )
+      sig { override.returns(IconInput) }
+      def tree_switcher_icon
+        @switcher_icon
       end
 
-      def node_data(node, index:, total:, has_next:)
-        {
-          hakumi__tree_target: "node",
-          key: node[:key],
-          parent_key: node[:parent_key],
-          level: node[: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
-        }
+      sig { override.returns(IconInput) }
+      def tree_icon
+        @icon
       end
 
-      def node_aria(node)
-        aria = {
-          expanded: node[:leaf] ? nil : expanded?(node[:key]),
-          selected: selected?(node[:key])
-        }
-
-        aria.compact
+      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?
 
-
-      def render_node_content_wrapper(node)
-        content_tag(:div,
-          class: "hakumi-tree-node-content-wrapper",
-          data: {
-            hakumi__tree_target: "content",
-            action: "click->hakumi--tree#select"
-          }
-        ) do
-          safe_join([
-            render_checkbox(node),
-            render_icon(node),
-            render_title(node)
-          ].compact)
-        end
-      end
-
-      def render_switcher(node)
-        icon_name = node[:switcher_icon]
-        is_leaf = node[:leaf]
-
-        switcher_conf = if icon_name.present?
-          normalize_switcher_conf(icon_name)
-        elsif @switcher_icon.present?
-          normalize_switcher_conf(@switcher_icon)
-        elsif @show_line
-          { collapse: :plus_square, expand: :minus_square }
+        array = if value.is_a?(Array)
+          value
+        elsif value.is_a?(String)
+          parsed = JSON.parse(value)
+          parsed.is_a?(Array) ? parsed : []
         else
-          { default: :caret_right }
+          []
         end
 
-        content_tag(:button,
-          type: "button",
-          class: switcher_classes(is_leaf),
-          aria: { label: is_leaf ? "Leaf" : "Toggle" },
-          data: {
-            action: (is_leaf ? nil : "click->hakumi--tree#toggle"),
-            hakumi__tree_target: "switcher",
-            key: node[:key]
-          }.compact
-        ) do
-          if is_leaf
-            content_tag(:span, "", class: "hakumi-tree-switcher-noop")
-          elsif switcher_conf[:default]
-            content_tag(:span, class: "hakumi-tree-switcher-icon") do
-              render HakumiComponents::Icon::Component.new(name: switcher_conf[:default])
-            end
-          else
-            content_tag(:span, class: "hakumi-tree-switcher-icon hakumi-tree-switcher-dual") do
-              safe_join([
-                content_tag(:span, class: "hakumi-tree-icon-collapse") { render HakumiComponents::Icon::Component.new(name: switcher_conf[:collapse]) },
-                content_tag(:span, class: "hakumi-tree-icon-expand") { render HakumiComponents::Icon::Component.new(name: switcher_conf[:expand]) }
-              ])
-            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
 
-      def normalize_switcher_conf(icon_or_conf)
-        return icon_or_conf if icon_or_conf.is_a?(Hash)
+      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?
 
-        case icon_or_conf.to_sym
-        when :plus, :plus_square, :plus_circle
-          suffix = icon_or_conf.to_s.gsub("plus", "")
-          { collapse: icon_or_conf, expand: :"minus#{suffix}" }
-        when :folder, :folder_open
-          { collapse: :folder, expand: :folder_open }
+        array = if value.is_a?(Array)
+          value
+        elsif value.is_a?(String)
+          parsed = JSON.parse(value)
+          parsed.is_a?(Array) ? parsed : []
         else
-          { default: icon_or_conf }
-        end
-      end
-      def render_checkbox(node)
-        return unless @checkable && node[:checkable]
-
-        content_tag(:button,
-          type: "button",
-          class: "hakumi-tree-checkbox",
-          aria: { checked: checked?(node[:key]) },
-          data: {
-            action: "click->hakumi--tree#toggleCheck",
-            hakumi__tree_target: "checkbox",
-            key: node[:key],
-            disabled: node[:disable_checkbox]
-          }
-        ) do
-          content_tag(:span, "", class: "hakumi-tree-checkbox-inner")
-        end
-      end
-
-      def render_icon(node)
-        icon_name = node[:icon]
-        if icon_name.blank? && @directory
-          icon_name = node[:leaf] ? :file : :folder
+          []
         end
 
-        return if icon_name.blank?
-
-        content_tag(:span, class: "hakumi-tree-icon") do
-          render HakumiComponents::Icon::Component.new(name: icon_name)
-        end
-      end
-
-      def render_title(node)
-        content_tag(:button,
-          type: "button",
-          class: "hakumi-tree-title",
-          data: {
-            action: "click->hakumi--tree#select",
-            hakumi__tree_target: "title",
-            key: node[:key]
-          }
-        ) do
-          content_tag(:span, node[:title], class: "hakumi-tree-title-text", data: { title: node[:title] })
-        end
-      end
-
-      def render_node_children(node, level_mask = [])
-        return if node[:children].empty?
-
-        content_tag(:div, class: "hakumi-tree-children", role: "group", data: { hakumi__tree_target: "children" }) do
-          render_nodes(node[:children], level_mask: level_mask)
+        array.filter_map do |entry|
+          case entry
+          when String, Symbol, Numeric
+            entry
+          else
+            nil
+          end
         end
+      rescue JSON::ParserError
+        []
       end
 
-      def switcher_classes(is_leaf)
-        class_names("tree-switcher", { leaf: is_leaf })
-      end
-
+      sig { override.params(key: String).returns(T::Boolean) }
       def expanded?(key)
-        expanded_keys = @expanded_keys || @default_expand_keys
-        expanded_keys.map(&:to_s).include?(key.to_s)
+        (@expanded_keys || @default_expand_keys).include?(key)
       end
 
+      sig { override.params(key: String).returns(T::Boolean) }
       def selected?(key)
-        selected_keys = @selected_keys || @default_selected_keys
-        selected_keys.map(&:to_s).include?(key.to_s)
+        (@selected_keys || @default_selected_keys).include?(key)
       end
 
+      sig { override.params(key: String).returns(T::Boolean) }
       def checked?(key)
-        checked_keys = @checked_keys || @default_checked_keys
-        checked_keys.map(&:to_s).include?(key.to_s)
+        (@checked_keys || @default_checked_keys).include?(key)
       end
 
+      sig { override.params(_key: String).returns(T::Boolean) }
       def half_checked?(_key)
         false
       end
-
-      def self.parse_nodes(value)
-        return [] if value.blank?
-        return value if value.is_a?(Array)
-
-        JSON.parse(value)
-      rescue JSON::ParserError
-        []
-      end
-
-      def self.parse_json_array(value, allow_nil: false)
-        return nil if allow_nil && value.nil?
-        return [] if value.blank?
-        return value if value.is_a?(Array)
-
-        JSON.parse(value)
-      rescue JSON::ParserError
-        []
-      end
-
-      def self.boolean_param(value, default: false)
-        return default if value.nil?
-
-        ActiveModel::Type::Boolean.new.cast(value)
-      end
     end
   end
 end