hakumi_components 0.1.18.pre → 0.1.19.pre

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

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