hakumi_components 0.1.17.pre → 0.1.19.pre

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

@@ -1,523 +0,0 @@
-# frozen_string_literal: true
-
-module Hakumi
-  module Tree
-    class Component < Hakumi::BaseComponent
-      DEFAULT_INDENT = 24
-
-      def self.extract_controller_locals(params)
-        {
-          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])
-        }
-      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: "Search",
-        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
-
-        validate_props!
-        @normalized_nodes = normalize_nodes(@nodes)
-      end
-
-      attr_reader :normalized_nodes
-
-      def wrapper_attributes
-        base_attrs = {
-          class: wrapper_classes,
-          data: data_attributes
-        }
-
-        merge_attributes(base_attrs, @html_options)
-      end
-
-      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
-      end
-
-      def searchable?
-        @searchable
-      end
-
-      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 Hakumi::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 Hakumi::Icon::Component.new(name: switcher_conf[:collapse]) },
-              content_tag(:span, class: "hakumi-tree-icon-expand") { render Hakumi::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 Hakumi::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
-
-      def wrapper_classes
-        class_names(
-          "tree",
-          {
-            checkable: @checkable,
-            "show-line": @show_line,
-            directory: @directory,
-            draggable: @draggable,
-            "block-node": @block_node,
-            disabled: @disabled,
-            searchable: @searchable,
-            virtual: @height.present?
-          },
-          [ @html_options[:class] ]
-        )
-      end
-
-      def list_classes
-        class_names("tree-list", { virtual: @height.present? })
-      end
-
-      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[: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
-      end
-
-      def validate_props!
-        raise ArgumentError, "nodes is required" if @nodes.nil?
-        raise ArgumentError, "nodes must be an Array" unless @nodes.is_a?(Array)
-      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
-      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
-      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]
-          }
-        )
-      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
-        }
-      end
-
-      def node_aria(node)
-        aria = {
-          expanded: node[:leaf] ? nil : expanded?(node[:key]),
-          selected: selected?(node[:key])
-        }
-
-        aria.compact
-      end
-
-
-
-      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 }
-        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 Hakumi::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 Hakumi::Icon::Component.new(name: switcher_conf[:collapse]) },
-                content_tag(:span, class: "hakumi-tree-icon-expand") { render Hakumi::Icon::Component.new(name: switcher_conf[:expand]) }
-              ])
-            end
-          end
-        end
-      end
-
-      def normalize_switcher_conf(icon_or_conf)
-        return icon_or_conf if icon_or_conf.is_a?(Hash)
-
-        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 }
-        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 Hakumi::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)
-        end
-      end
-
-      def switcher_classes(is_leaf)
-        class_names("tree-switcher", { leaf: is_leaf })
-      end
-
-      def expanded?(key)
-        expanded_keys = @expanded_keys || @default_expand_keys
-        expanded_keys.map(&:to_s).include?(key.to_s)
-      end
-
-      def selected?(key)
-        selected_keys = @selected_keys || @default_selected_keys
-        selected_keys.map(&:to_s).include?(key.to_s)
-      end
-
-      def checked?(key)
-        checked_keys = @checked_keys || @default_checked_keys
-        checked_keys.map(&:to_s).include?(key.to_s)
-      end
-
-      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