ariadne_view_components 0.0.43 → 0.0.44

data/app/components/ariadne/component.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require "view_component/version"
+
+require "heroicons_helper"
+
+module Ariadne
+  # @private
+  class Component < ViewComponent::Base
+    include ClassNameHelper
+    include FetchOrFallbackHelper
+    include ViewHelper
+    include Status::Dsl
+    include Audited::Dsl
+    include LoggerHelper
+    include Ariadne::ActionViewExtensions::FormHelper
+
+    BASE_WRAPPER_CLASSES = "ariadne-flex ariadne-flex-col ariadne-h-screen ariadne-justify-between"
+    BASE_MAIN_CLASSES = "ariadne-flex-auto"
+
+    # this is defined here for the Tailwind parser to pick up; it can be useful
+    # in situations where hiddenness is defined by a kwarg, eg `selected: false`
+    BASE_HIDDEN_CLASS = "ariadne-hidden"
+
+    INVALID_ARIA_LABEL_TAGS = [:div, :span, :p].freeze
+
+    private def raise_on_invalid_options?
+      Rails.application.config.ariadne_view_components.raise_on_invalid_options
+    end
+
+    private def raise_on_invalid_aria?
+      Rails.application.config.ariadne_view_components.raise_on_invalid_aria
+    end
+
+    private def deprecated_component_warning(new_class: nil, version: nil)
+      return if silence_deprecations?
+
+      message = "#{self.class.name} is deprecated"
+      message += " and will be removed in v#{version}." if version
+      message += " Use #{new_class.name} instead." if new_class
+
+      ActiveSupport::Deprecation.warn(message)
+    end
+
+    private def aria(val, attributes)
+      attributes[:"aria-#{val}"] || attributes.dig(:aria, val.to_sym)
+    end
+
+    private def validate_aria_label!
+      aria_label = aria("label", @attributes)
+      raise ArgumentError, "`aria-label` is required." if aria_label.blank?
+    end
+
+    private def check_denylist(denylist = [], attributes = {})
+      if should_raise_error?
+
+        # Convert denylist from:
+        # { [:p, :pt] => "message" } to:
+        # { p: "message", pt: "message" }
+        unpacked_denylist =
+          denylist.each_with_object({}) do |(keys, value), memo|
+            keys.each { |key| memo[key] = value }
+          end
+
+        violations = unpacked_denylist.keys & attributes.keys
+
+        if violations.any?
+          message = "Found #{violations.count} #{"violation".pluralize(violations)}:"
+          violations.each do |violation|
+            message += "\n The #{violation} argument is not allowed here. #{unpacked_denylist[violation]}"
+          end
+
+          raise(ArgumentError, message)
+        end
+      end
+
+      attributes
+    end
+
+    private def validate_attributes(tag:, denylist_name: :attributes_denylist, attributes: {})
+      deny_single_argument(:class, "Use `classes` instead.", attributes)
+
+      if (denylist = attributes[denylist_name])
+        check_denylist(denylist, attributes)
+
+        # Remove :attributes_denylist key and any denied keys from attributes
+        attributes.except!(denylist_name)
+        attributes.except!(*denylist.keys.flatten)
+      end
+
+      deny_aria_label(tag: tag, attributes: attributes)
+
+      attributes
+    end
+
+    private def deny_single_argument(key, help_text, attributes)
+      raise ArgumentError, "`#{key}` is an invalid argument. #{help_text}" \
+        if should_raise_error? && attributes.key?(key)
+
+      attributes.except!(key)
+    end
+
+    private def deny_aria_label(tag:, attributes:)
+      return attributes.except!(:skip_aria_label_check) if attributes[:skip_aria_label_check]
+      return if attributes[:role]
+      return unless INVALID_ARIA_LABEL_TAGS.include?(tag)
+
+      deny_aria_key(
+        :label,
+        "Don't use `aria-label` on `#{tag}` elements. See https://www.tpgi.com/short-note-on-aria-label-aria-labelledby-and-aria-describedby/",
+        attributes,
+      )
+    end
+
+    private def deny_aria_key(key, help_text, attributes)
+      raise ArgumentError, help_text if should_raise_aria_error? && aria(key, attributes)
+    end
+
+    private def should_raise_error?
+      raise_on_invalid_options? && !ENV["ARIADNE_WARNINGS_DISABLED"]
+    end
+
+    private def should_raise_aria_error?
+      raise_on_invalid_aria? && !ENV["ARIADNE_WARNINGS_DISABLED"]
+    end
+  end
+end

data/app/components/ariadne/container_component/container_component.html.erb

@@ -0,0 +1,3 @@
+<%= render Ariadne::BaseComponent.new(tag: @tag, classes: @classes, attributes: @attributes) do |component| %>
+  <%= content %>
+<% end %>

data/app/components/ariadne/container_component.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Ariadne
+  # The container wraps the majority, if not all, of the content on a page.
+  class ContainerComponent < Ariadne::Component
+    DEFAULT_CLASSES = "ariadne-px-4 sm:ariadne-px-6 lg:ariadne-px-8"
+
+    # @example Default
+    #   <%= render(Ariadne::ContainerComponent.new) do |container| %>
+    #     <%= render(Ariadne::ButtonComponent.new) { "Click me!" } %>
+    #   <% end %>
+    #
+    # @param classes [String] <%= link_to_classes_docs %>
+    # @param attributes [Hash] <%= link_to_attributes_docs %>
+    def initialize(classes: "", attributes: {})
+      @tag = :div
+      @classes = merge_class_names(
+        DEFAULT_CLASSES,
+        classes,
+      )
+
+      @attributes = attributes
+    end
+  end
+end

data/app/components/ariadne/content.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Ariadne
+  #
+  # Use `Content` as a helper to render content passed to a slot without adding any tags.
+  #
+  class Content < Ariadne::Component
+    def call
+      content
+    end
+  end
+end

data/app/components/ariadne/counter_component.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Ariadne
+  # Use `CounterComponent` to add a count to navigational elements and buttons.
+  #
+  # @accessibility
+  #   Always use `CounterComponent` with adjacent text that provides supplementary information regarding what the count is for. For instance, `Counter`
+  #   should be accompanied with text such as `issues` or `pull requests`.
+  #
+  class CounterComponent < Ariadne::Component
+    DEFAULT_CLASSES = "ariadne-inline-flex ariadne-items-center ariadne-p-1 ariadne-border ariadne-border-transparent ariadne-rounded-full ariadne-shadow-sm focus:ariadne-outline-none focus:ariadne-ring-2 focus:ariadne-ring-offset-2"
+
+    # @example Default
+    #   <%= render(Ariadne::CounterComponent.new(count: 25)) %>
+    #
+    # @example Schemes
+    #   <%= render(Ariadne::CounterComponent.new(count: 25)) %>
+    #   <%= render(Ariadne::CounterComponent.new(count: 25)) %>
+    #
+    # @param tag [Symbol, String] The rendered tag name
+    # @param classes [String] <%= link_to_classes_docs %>
+    # @param count [Integer, Float::INFINITY, nil] The number to be displayed (e.x. # of issues, pull requests)
+    # @param limit [Integer, nil] Maximum value to display. Pass `nil` for no limit. (e.x. if `count` == 6,000 and `limit` == 5000, counter will display "5,000+")
+    # @param hide_if_zero [Boolean] If true, a `hidden` attribute is added to the counter if `count` is zero.
+    # @param text [String] Text to display instead of count.
+    # @param round [Boolean] Whether to apply rounding logic to value.
+    # @param attributes [Hash] <%= link_to_attributes_docs %>
+    def initialize(
+      tag: :span,
+      count: 0,
+      limit: 9_000,
+      hide_if_zero: false,
+      text: "",
+      round: false,
+      classes: "",
+      attributes: {}
+    )
+      @count = count
+      @limit = limit
+      @hide_if_zero = hide_if_zero
+      @text = text
+      @round = round
+      @attributes = attributes
+
+      @has_limit = !@limit.nil?
+
+      @tag = check_incoming_tag(:span, tag)
+
+      @attributes[:title] = title
+
+      @classes = merge_class_names(
+        DEFAULT_CLASSES,
+        classes,
+      )
+      @attributes[:hidden] = true if count == 0 && hide_if_zero
+    end
+
+    def call
+      render(Ariadne::BaseComponent.new(tag: @tag, classes: @classes, attributes: @attributes)) { value }
+    end
+
+    private def title
+      if @text.present?
+        @text
+      elsif @count.nil?
+        "Not available"
+      elsif @count == Float::INFINITY
+        "Infinity"
+      else
+        count = @count.to_i
+        str = number_with_delimiter(@has_limit ? [count, @limit].min : count)
+        str += "+" if @has_limit && count > @limit
+        str
+      end
+    end
+
+    private def value
+      if @text.present?
+        @text
+      elsif @count.nil?
+        "" # CSS will hide it
+      elsif @count == Float::INFINITY
+        "∞"
+      else
+        if @round
+          count = @has_limit ? [@count.to_i, @limit].min : @count.to_i
+          precision = count.between?(100_000, 999_999) ? 0 : 1
+          units = { thousand: "k", million: "m", billion: "b" }
+          str = number_to_human(count, precision: precision, significant: false, units: units, format: "%n%u")
+        else
+          @count = @count.to_i
+          str = number_with_delimiter(@has_limit ? [@count, @limit].min : @count)
+        end
+
+        str += "+" if @has_limit && @count.to_i > @limit
+        str
+      end
+    end
+  end
+end

data/app/components/ariadne/details_component/details_component.html.erb

@@ -0,0 +1,4 @@
+<%= render Ariadne::BaseComponent.new(tag: @tag, classes: @classes, attributes: @attributes) do |component| %>
+  <%= summary %>
+  <%= body %>
+<% end %>

data/app/components/ariadne/details_component.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Ariadne
+  # Use `DetailsComponent` to reveal content after clicking a button.
+  class DetailsComponent < Ariadne::Component
+    DEFAULT_TAG = :details
+    DEFAULT_BODY_TAG = :div
+
+    VALID_BODY_TAGS = [:ul, :"details-menu", :"details-dialog", DEFAULT_BODY_TAG].freeze
+
+    NO_OVERLAY = :none
+    OVERLAY_MAPPINGS = {
+      NO_OVERLAY => "",
+      :default => "",
+    }.freeze
+
+    # Use the Summary as a trigger to reveal the content.
+    #
+    # @param button [Boolean] (true) Whether to render the Summary as a button or not.
+    # @param classes [String] <%= link_to_classes_docs %>
+    # @param attributes [Hash] <%= link_to_attributes_docs %>
+    renders_one :summary, lambda { |button: true, classes: "", attributes: {}|
+      tag = :summary
+      attributes[:role] = "button"
+      if button
+        Ariadne::ButtonComponent.new(tag: tag, classes: classes, attributes: attributes)
+      else
+        Ariadne::BaseComponent.new(tag: tag, classes: classes, attributes: attributes)
+      end
+    }
+
+    DEFAULT_BODY_CLASSES = "ariadne-absolute ariadne-mt-2 ariadne-w-56 ariadne-divide-y ariadne-divide-gray-100 ariadne-rounded-md ariadne-shadow-lg ariadne-ring-1 ariadne-ring-black ariadne-ring-opacity-5 focus:ariadne-outline-none"
+    # Use the Body slot as the main content to be shown when triggered by the Summary.
+    #
+    # @param tag [Symbol] The tag to use for the body/ <%= one_of(Ariadne::DetailsComponent::VALID_BODY_TAGS) %>
+    # @param classes [String] <%= link_to_classes_docs %>
+    # @param attributes [Hash] <%= link_to_attributes_docs %>
+    renders_one :body, lambda { |tag: DEFAULT_BODY_TAG, classes: "", attributes: {}|
+      tag = fetch_or_raise(VALID_BODY_TAGS, tag)
+      actual_classes = merge_class_names(DEFAULT_BODY_CLASSES, classes)
+
+      Ariadne::BaseComponent.new(tag: tag, classes: actual_classes, attributes: attributes)
+    }
+
+    DEFAULT_CLASSES = ""
+
+    # @example Default
+    #
+    #   <%= render Ariadne::DetailsComponent.new do |c| %>
+    #     <% c.with_summary do %>
+    #       Summary
+    #     <% end %>
+    #     <% c.with_body do %>
+    #       Body
+    #     <% end %>
+    #   <% end %>
+    #
+    # @param overlay [Symbol] Dictates the type of overlay to render with. <%= one_of(Ariadne::DetailsComponent::OVERLAY_MAPPINGS.keys) %>
+    # @param reset [Boolean] If set to true, it will remove the default caret and remove style from the summary element
+    # @param classes [String] <%= link_to_classes_docs %>
+    # @param attributes [Hash] <%= link_to_attributes_docs %>
+    def initialize(overlay: NO_OVERLAY, reset: true, classes: "", attributes: {})
+      @tag = DEFAULT_TAG
+      @reset = reset
+
+      @classes = merge_class_names(
+        DEFAULT_CLASSES,
+        classes,
+        @reset ? "ariadne__details-reset" : "",
+      )
+
+      @attributes = attributes
+
+      @overlay = fetch_or_raise(OVERLAY_MAPPINGS.keys, overlay)
+    end
+
+    def render?
+      summary? && body?
+    end
+  end
+end

data/app/components/ariadne/dropdown/menu_component.html.erb

@@ -0,0 +1,20 @@
+<%= render Ariadne::BaseComponent.new(tag: @tag, classes: @classes, attributes: @attributes) do |component| %>
+  <%= header %>
+  <% if list? %>
+    <ul>
+      <% items.each do |item| %>
+        <% if item.divider? %>
+          <%= item %>
+        <% else %>
+          <li>
+            <%= item %>
+          </li>
+        <% end %>
+      <% end %>
+    </ul>
+  <% else %>
+    <% items.each do |item| %>
+      <%= item %>
+    <% end %>
+  <% end %>
+<% end %>

data/app/components/ariadne/dropdown/menu_component.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Ariadne
+  module Dropdown
+    # This component is part of `DropdownComponent` and should not be
+    # used as a standalone component.
+    class MenuComponent < Ariadne::Component
+      DEFAULT_AS_OPTION = :default
+      VALID_AS_OPTIONS = [DEFAULT_AS_OPTION, :list].freeze
+
+      DEFAULT_DIRECTION = :se
+      VALID_DIRECTIONS = [DEFAULT_DIRECTION, :sw, :w, :e, :ne, :s].freeze
+
+      DEFAULT_HEADER_CLASSES = "ariadne-text-sm ariadne-font-medium ariadne-text-gray-900"
+      # @param classes [String] <%= link_to_classes_docs %>
+      # @param attributes [Hash] <%= link_to_attributes_docs %>
+      renders_one :header, lambda { |classes: "", attributes: {}|
+        actual_classes = merge_class_names(DEFAULT_HEADER_CLASSES, classes)
+        Ariadne::BaseComponent.new(tag: :span, classes: actual_classes, attributes: attributes)
+      }
+
+      # @param tag [Boolean] <%= one_of(Ariadne::Dropdown::MenuComponent::Item::VALID_TAGS) %>.
+      # @param divider [Boolean] Whether the item is a divider without any function.
+      # @param classes [String] <%= link_to_classes_docs %>
+      # @param attributes [Hash] <%= link_to_attributes_docs %>
+      renders_many :items, lambda { |tag: Ariadne::Dropdown::MenuComponent::Item::DEFAULT_TAG, divider: false, classes: "", attributes: {}|
+        Ariadne::Dropdown::MenuComponent::Item.new(tag: tag, as: @as, divider: divider, classes: classes, attributes: attributes)
+      }
+
+      DEFAULT_TAG = :"details-menu"
+      TAG_OPTIONS = [DEFAULT_TAG].freeze
+
+      DEFAULT_CLASSES = ""
+
+      # @param as [Symbol] When `as` is `:list`, wraps the menu in a `<ul>` with a `<li>` for each item.
+      # @param direction [Symbol] <%= one_of(Ariadne::Dropdown::MenuComponent::VALID_DIRECTIONS) %>.
+      # @param classes [String] <%= link_to_classes_docs %>
+      # @param attributes [Hash] <%= link_to_attributes_docs %>
+      def initialize(as: DEFAULT_AS_OPTION, direction: VALID_DIRECTIONS, classes: "", attributes: {})
+        @tag = DEFAULT_TAG
+        @classes = merge_class_names(
+          DEFAULT_CLASSES,
+          classes,
+        )
+
+        @attributes = attributes
+
+        @direction = direction
+        @as = fetch_or_raise(VALID_AS_OPTIONS, as)
+
+        @attributes[:role] = "menu"
+      end
+
+      private def list?
+        @as == :list
+      end
+
+      # Items to be rendered in the `Dropdown` menu.
+      class Item < Ariadne::Component
+        DEFAULT_TAG = :a
+        BUTTON_TAGS = [:button, :summary].freeze
+        VALID_TAGS = [DEFAULT_TAG, *BUTTON_TAGS].freeze
+
+        DEFAULT_ITEM_CLASSES = "ariadne-block ariadne-px-4 ariadne-py-2 ariadne-text-sm ariadne-text-gray-700"
+
+        def initialize(as:, tag: DEFAULT_TAG, divider: false, classes: "", attributes: {})
+          @divider = divider
+          @as = as
+
+          @classes = merge_class_names(DEFAULT_ITEM_CLASSES, classes)
+          @attributes = attributes
+          @tag = fetch_or_raise(VALID_TAGS, tag)
+          @tag = :li if list? && divider?
+          @attributes[:role] ||= :menuitem
+          @attributes[:role] = :separator if @divider
+        end
+
+        def call
+          component = if BUTTON_TAGS.include?(@tag)
+            Ariadne::ButtonComponent.new(scheme: Ariadne::ButtonComponent::LINK_SCHEME, classes: @classes, attributes: @attributes)
+          else
+            Ariadne::BaseComponent.new(tag: @tag, classes: @classes, attributes: @attributes)
+          end
+
+          # divider has no content
+          render(component) if divider?
+
+          render(component) { content }
+        end
+
+        def divider?
+          @divider
+        end
+
+        def list?
+          @as == :list
+        end
+      end
+    end
+  end
+end

data/app/components/ariadne/dropdown/menu_component.ts

@@ -0,0 +1 @@
+import '@github/details-menu-element'

data/app/components/ariadne/dropdown_component/dropdown_component.html.erb

@@ -0,0 +1,8 @@
+<%= render(Ariadne::DetailsComponent.new(classes: @classes, attributes: @attributes)) do |c| %>
+  <% c.with_summary(classes: @button_classes, attributes: @button_attributes) do %>
+    <%= button %>
+  <% end %>
+  <% c.with_body do %>
+    <%= menu %>
+  <% end %>
+<% end %>

data/app/components/ariadne/dropdown_component.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+module Ariadne
+  # `DropdownComponent` is a lightweight context menu for holding navigation and actions.
+  class DropdownComponent < Ariadne::Component
+    DEFAULT_TAG = :div
+    TAG_OPTIONS = [DEFAULT_TAG].freeze
+
+    DEFAULT_CLASSES = ""
+
+    # Required trigger for the dropdown. Has the same arguments as <%= link_to_component(Ariadne::ButtonComponent) %>,
+    # but it is locked as a `summary` tag.
+    #
+    # @param size [Symbol] <%= one_of(Ariadne::BaseButton::VALID_SIZES) %>
+    # @param type [Symbol] <%= one_of(Ariadne::BaseButton::VALID_TYPES) %>
+    # @param scheme [Symbol] <%= one_of(Ariadne::ButtonComponent::VALID_SCHEMES) %>
+    # @param classes [String] <%= link_to_classes_docs %>
+    # @param attributes [Hash] <%= link_to_attributes_docs %>
+    renders_one :button, lambda { |size: Ariadne::BaseButton::DEFAULT_SIZE, scheme: :none, classes: "", attributes: {}|
+      @button_classes = classes
+      @button_attributes = attributes
+      @button_attributes[:button] = true
+
+      Ariadne::ButtonComponent.new(tag: :summary, type: :button, scheme: scheme, dropdown: @with_caret, size: size, classes: classes, attributes: attributes)
+    }
+
+    # Required context menu for the dropdown.
+    #
+    # @param as [Symbol] When `as` is `:list`, wraps the menu in a `<ul>` with a `<li>` for each item.
+    # @param direction [Symbol] <%= one_of(Ariadne::Dropdown::MenuComponent::VALID_DIRECTIONS) %>
+    # @param header [String] Optional string to display as the header
+    # @param classes [String] <%= link_to_classes_docs %>
+    # @param attributes [Hash] <%= link_to_attributes_docs %>
+    renders_one :menu, "Ariadne::Dropdown::MenuComponent"
+    # TODO: remove *Item suffix from nested classes
+
+    # @example Default
+    #   <%= render(Ariadne::DropdownComponent.new) do |c| %>
+    #     <% c.with_button do %>
+    #       Dropdown
+    #     <% end %>
+    #
+    #     <% c.with_menu do |menu| %>
+    #      <% menu.with_header { "Header" } %>
+    #       <% menu.with_item { "Item 1" } %>
+    #       <% menu.with_item { "Item 2" } %>
+    #       <% menu.with_item { "Item 3" } %>
+    #     <% end %>
+    #   <% end %>
+    #
+    # @example With dividers
+    #
+    #   @description
+    #     Dividers can be used to separate a group of items. They don't have any content.
+    #   @code
+    #     <%= render(Ariadne::DropdownComponent.new) do |c| %>
+    #       <% c.with_button do %>
+    #         Dropdown
+    #       <% end %>
+    #
+    #     <% c.with_menu do |menu| %>
+    #       <% menu.with_header { "Header" } %>
+    #       <%= menu.with_item { "Item 1" } %>
+    #       <%= menu.with_item { "Item 2" } %>
+    #       <%= menu.with_item(divider: true) %>
+    #       <%= menu.with_item { "Item 3" } %>
+    #       <%= menu.with_item { "Item 4" } %>
+    #       <%= menu.with_item(divider: true) %>
+    #       <%= menu.with_item { "Item 5" } %>
+    #       <%= menu.with_item { "Item 6" } %>
+    #     <% end %>
+    #    <% end %>
+    #
+    # @example With direction
+    #   <%= render(Ariadne::DropdownComponent.new) do |c| %>
+    #     <% c.with_button do %>
+    #       Dropdown
+    #     <% end %>
+    #
+    #     <% c.with_menu(direction: :s) do |menu| %>
+    #       <% menu.header { "Header" } %>
+    #       <%= menu.with_item { "Item 1" } %>
+    #       <%= menu.with_item { "Item 2" } %>
+    #       <%= menu.with_item { "Item 3" } %>
+    #       <%= menu.with_item { "Item 4" } %>
+    #     <% end %>
+    #   <% end %>
+    #
+    # @example With caret
+    #   <%= render(Ariadne::DropdownComponent.new(with_caret: true)) do |c| %>
+    #     <% c.with_button do %>
+    #       Dropdown
+    #     <% end %>
+    #
+    #     <% c.with_menu do |menu| %>
+    #       <% menu.with_header { "Header" } %>
+    #       <%= menu.with_item { "Item 1" } %>
+    #       <%= menu.with_item { "Item 2" } %>
+    #       <%= menu.with_item { "Item 3" } %>
+    #       <%= menu.with_item { "Item 4" } %>
+    #     <% end %>
+    #   <% end %>
+    #
+    # @example Customizing the button
+    #   <%= render(Ariadne::DropdownComponent.new) do |c| %>
+    #     <% c.with_button(scheme: :info, size: :sm) do %>
+    #       Dropdown
+    #     <% end %>
+    #
+    #     <% c.with_menu do |menu| %>
+    #       <% menu.with_header { "Header" } %>
+    #       <%= menu.with_item { "Item 1" } %>
+    #       <%= menu.with_item { "Item 2" } %>
+    #       <%= menu.with_item { "Item 3" } %>
+    #       <%= menu.with_item { "Item 4" } %>
+    #    <% end %>
+    #   <% end %>
+    #
+    # @example Menu as list
+    #   <%= render(Ariadne::DropdownComponent.new) do |c| %>
+    #     <% c.with_button do %>
+    #       Dropdown
+    #     <% end %>
+    #
+    #     <% c.with_menu(as: :list) do |menu| %>
+    #       <% menu.with_header { "Header" } %>
+    #       <% menu.with_item { "Item 1" } %>
+    #       <% menu.with_item { "Item 2" } %>
+    #       <% menu.with_item(divider: true) %>
+    #       <% menu.with_item { "Item 3" } %>
+    #       <% menu.with_item { "Item 4" } %>
+    #     <% end %>
+    #   <% end %>
+    #
+    # @example Customizing menu items
+    #   <%= render(Ariadne::DropdownComponent.new) do |c| %>
+    #     <% c.with_button do %>
+    #       Dropdown
+    #     <% end %>
+    #
+    #     <% c.with_menu do |menu| %>
+    #       <% menu.with_header { "Header" } %>
+    #       <% menu.with_item(tag: :button) { "Item 1" } %>
+    #       <% menu.with_item(classes: "ariadne-text-red-500") { "Item 2" } %>
+    #       <% menu.with_item { "Item 3" } %>
+    #     <% end %>
+    #   <% end %>
+    #
+    # @param overlay [Symbol] <%= one_of(Ariadne::DetailsComponent::OVERLAY_MAPPINGS.keys) %>
+    # @param with_caret [Boolean] Whether or not a caret should be rendered in the button.
+    # @param classes [String] <%= link_to_classes_docs %>
+    # @param attributes [Hash] <%= link_to_attributes_docs %>
+    def initialize(overlay: :default, with_caret: false, classes: "", attributes: {})
+      @tag = check_incoming_tag(DEFAULT_TAG, tag)
+      @classes = merge_class_names(
+        DEFAULT_CLASSES,
+        classes,
+      )
+
+      @attributes = attributes
+
+      @with_caret = with_caret
+
+      @overlay = overlay
+      @attributes[:reset] = true
+    end
+
+    def render?
+      button.present? && menu.present?
+    end
+  end
+end