poetry-ui 0.0.2

data/app/components/poetry/ui/menubar/style.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Poetry
+  module Ui
+    module Menubar
+      # Re-expressed through the cn-* theme layer, the source quirks
+      # preserved in the theme rules verbatim (content omits
+      # data-closed:animate-out, checkbox/radio round with rounded-xs, the
+      # sub-trigger has no [&_svg] block). :menu keeps display:contents
+      # inline - the one poetry addition (controller host erased from
+      # layout + the a11y tree).
+      class Style < Poetry::Core::Style
+        base "cn-menubar flex items-center"
+
+        # POETRY ADDITION: the logical Menu grouping needs a host element
+        # for its behavior wiring; display:contents erases it from layout
+        # and the a11y tree (the source anatomy renders no element here).
+        element :menu, "contents"
+
+        element :trigger, "cn-menubar-trigger flex items-center outline-hidden select-none"
+
+        element :content, "cn-menubar-content cn-menu-translucent z-50 " \
+                          "origin-(--transform-origin) overflow-hidden"
+
+        # group/menubar-item: bare marker, no CSS - the vega theme's
+        # shortcut re-color (group-focus/menubar-item) keys on it.
+        element :item, "cn-menubar-item group/menubar-item relative flex cursor-default items-center " \
+                       "outline-hidden select-none [&_svg]:pointer-events-none [&_svg]:shrink-0 " \
+                       "data-disabled:opacity-50 data-disabled:pointer-events-none"
+
+        element :checkbox_item, "cn-menubar-checkbox-item relative flex cursor-default items-center outline-hidden " \
+                                "select-none [&_svg]:pointer-events-none [&_svg]:shrink-0 data-disabled:opacity-50 " \
+                                "data-disabled:pointer-events-none"
+
+        element :radio_item, "cn-menubar-radio-item relative flex cursor-default items-center outline-hidden " \
+                             "select-none [&_svg]:pointer-events-none [&_svg]:shrink-0 data-disabled:opacity-50 " \
+                             "data-disabled:pointer-events-none"
+
+        element :label, "cn-menubar-label"
+
+        element :separator, "cn-menubar-separator -mx-1 h-px my-1"
+
+        element :shortcut, "cn-menubar-shortcut"
+
+        # DELTA vs the family: outline-none (not -hidden), no [&_svg] block
+        # (source-exact).
+        element :sub_trigger, "cn-menubar-sub-trigger flex cursor-default items-center " \
+                              "outline-none select-none"
+
+        element :sub_content, "cn-menubar-sub-content z-50 " \
+                              "origin-(--transform-origin) overflow-hidden"
+
+        # Source-exact wrapper span (anonymous in the ported source; poetry names
+        # it menubar-item-indicator - the self-identification rule).
+        element :item_indicator, "pointer-events-none absolute " \
+                                 "flex items-center justify-center"
+
+        # POETRY ADDITION (family convention): the indicator stays in the
+        # DOM; the parent item's data-checked/data-unchecked pair drives
+        # visibility.
+        element :item_indicator_state, "[[data-unchecked]>&]:hidden"
+
+        # The source's inline lucide icon classes, named per part. DELTA:
+        # the menubar sub chevron is ml-auto h-4 w-4 (source-exact).
+        element :indicator_check, "size-4"
+        element :indicator_circle, "size-2 fill-current"
+        element :sub_indicator, "ml-auto h-4 w-4"
+      end
+    end
+  end
+end

data/app/components/poetry/ui/menus.rb

@@ -0,0 +1,386 @@
+# frozen_string_literal: true
+
+module Poetry
+  module Ui
+    # Gives a menu family (DropdownMenu, ContextMenu, Menubar) one shared
+    # implementation of the menu item union and its anatomy classes.
+    # Family identity - the data-slot prefix, the Style dictionary, the
+    # error noun, the builder classes - resolves through the including
+    # family's namespace at render time, never through constants named
+    # here, so one implementation serves every family. Each family keeps
+    # a thin ItemSlots module carrying its own SLOT_BUILDERS and, where
+    # needed, a per-kind indicator override.
+    module Menus
+      # The closed vocabulary for the item variant axis.
+      ITEM_VARIANTS = %i[default destructive].freeze
+
+      # Shared attribute builders for the item union - mixed into every
+      # menu level (the family roots and the nested Sub / Group /
+      # RadioGroup parts) so the whole family renders the same anatomy
+      # through the same Builder.
+      module Helpers
+        include FamilyIdentity
+
+        private
+
+        # menu items are role=menuitem DIVs (APG-exact) - no native
+        # disabled, so aria-disabled and data-disabled are written TOGETHER
+        # (the controller filters on either; CSS styles data-[disabled]).
+        def apply_item_flags(attrs, inset: false, disabled: false, text_value: nil, close_on_select: nil)
+          attrs["data-inset"] = "true" if inset
+          if disabled
+            attrs["aria-disabled"] = "true"
+            attrs["data-disabled"] = ""
+          end
+          attrs["data-text-value"] = text_value if text_value
+          attrs["data-close-on-select"] = close_on_select.to_s unless close_on_select.nil?
+          attrs
+        end
+
+        # Every menu item's activation, via the public escape hatch (each
+        # family Component's :item declaration mirrors it; the contract
+        # gate keeps the two in sync).
+        def item_action_attributes
+          stimulus_attributes(:menu) { |menu| menu.with_action(:activate, on: :click) }
+        end
+
+        # The named check/circle glyph wrapper (the source's two slots:
+        # <family>-checkbox-item-indicator / <family>-radio-item-indicator).
+        # State is carried by
+        # the parent item's aria-checked/data-checked pair; the glyph
+        # itself stays decorative (Icon defaults to aria-hidden).
+        def item_indicator(icon, icon_class, kind)
+          extra = [family_style.css(:item_indicator_state), indicator_extra_class(kind)].compact
+          content_tag(:span, "data-slot" => "#{family_slot_prefix}-#{kind}-item-indicator",
+                             "class" => family_style.css(:item_indicator, class: extra)) do
+            render(Icon::Component.new(name: icon, class: icon_class))
+          end
+        end
+
+        # The one substantive family fork: Menubar themes its checkbox and
+        # radio indicators separately (a per-kind cn class rides along);
+        # the siblings share one treatment.
+        def indicator_extra_class(_kind)
+          nil
+        end
+
+        # A VISUAL keybinding hint only - poetry does not bind the key
+        # (family rule), so the span is aria-hidden presentation.
+        def shortcut_span(text)
+          return if text.blank?
+
+          content_tag(:span, text, "data-slot" => "#{family_slot_prefix}-shortcut", "aria-hidden" => "true",
+                                   "class" => family_style.css(:shortcut))
+        end
+      end
+
+      # The item UNION every menu level accepts: item | checkbox_item |
+      # radio_group | label | separator | group | sub - one ordered
+      # collection (interleaving preserved), polymorphic setters named per
+      # part. Included (through each family's thin ItemSlots) by the family
+      # roots, Sub (recursive submenus), and Group.
+      module ItemSlots
+        extend ActiveSupport::Concern
+        include Helpers
+
+        included do
+          renders_many :items,
+                       doc: "The menu composition API: one ordered items collection accepting seven kinds, " \
+                            "interleaved in call order - with_item an action row (href: renders it as a real link; " \
+                            "submit: as a real submit button) with_checkbox_item a toggleable checked/unchecked row " \
+                            "with_radio_group a single-select scope; add rows inside it via with_radio_item(value:) " \
+                            "with_label a non-interactive heading for a run of items with_separator a horizontal " \
+                            "rule between runs with_group semantic grouping around the same union, one level down " \
+                            "with_sub a nested submenu: its own with_trigger plus the same union, recursively",
+                       types: {
+                         item: { renders: ->(**options, &block) { item_part(**options, &block) }, as: :item },
+                         checkbox_item: {
+                           renders: ->(**options, &block) { checkbox_item_part(**options, &block) }, as: :checkbox_item
+                         },
+                         radio_group: { renders: lambda { |**options|
+                           family_namespace::RadioGroup.new(**options)
+                         }, as: :radio_group },
+                         label: { renders: ->(**options, &block) { label_part(**options, &block) }, as: :label },
+                         separator: { renders: ->(**options) { separator_part(**options) }, as: :separator },
+                         group: { renders: lambda { |**options|
+                           family_namespace::Group.new(dir: menu_dir, **options)
+                         }, as: :group },
+                         sub: { renders: lambda { |**options|
+                           family_namespace::Sub.new(dir: menu_dir, **options)
+                         }, as: :sub }
+                       }
+        end
+
+        private
+
+        # Builds one action row - a role=menuitem div, or a real <a> /
+        # submit <button> when href: / submit: is given.
+        def item_part(**options, &)
+          variant = (options.delete(:variant) || :default).to_sym
+          unless ITEM_VARIANTS.include?(variant)
+            raise ArgumentError,
+                  "unknown #{family_name} item variant #{variant.inspect} - known: #{ITEM_VARIANTS.join(", ")}"
+          end
+
+          shortcut = options.delete(:shortcut)
+          # A link/submit item IS the interactive element (role=menuitem on the
+          # <a> or the <button>), never nested inside a menuitem div - one
+          # interactive element, so it keeps the APG contract without tripping
+          # nested-interactive a11y. A disabled link/submit drops its target and
+          # renders as the plain div (anchors/submit-buttons have no menu meaning
+          # once inert).
+          href = options.delete(:href)
+          external = options.delete(:external)
+          submit = options.delete(:submit)
+          method = options.delete(:method)
+          disabled = options[:disabled]
+          attrs = {
+            "data-slot" => "#{family_slot_prefix}-item", "role" => "menuitem", "tabindex" => "-1",
+            "data-poetry-collection-item" => "", "data-variant" => variant,
+            "class" => family_style.css(:item, class: options.delete(:class))
+          }.merge(item_action_attributes)
+          apply_item_flags(attrs, **options.extract!(:inset, :disabled, :text_value, :close_on_select))
+          content = safe_join([capture(&), shortcut_span(shortcut)].compact)
+
+          if submit && !disabled
+            # form: is RESERVED on submit items - the display:contents form
+            # IS the a11y mechanism (the button is the menuitem).
+            options.delete(:form)
+            options.delete("form")
+            # button_to's form is display:contents (transparent); the submit
+            # button IS the menuitem, POSTing with CSRF + the method override -
+            # the a11y-clean way to run a DELETE/POST action from a menu. The
+            # block form renders a <button> (the string form renders an <input>).
+            return helpers.button_to(submit,
+                                     { method: method || :post, form: { class: "contents" } }
+                                       .merge(Poetry::Core::HTML::Attributes.merged(attrs, options))) { content }
+          end
+
+          link = href && !disabled
+          if link
+            attrs["href"] = href
+            if external
+              attrs["target"] = "_blank"
+              attrs["rel"] = "noopener noreferrer"
+            end
+          end
+          content_tag(link ? :a : :div, Poetry::Core::HTML::Attributes.merged(attrs, options)) { content }
+        end
+
+        # Builds one role=menuitemcheckbox toggle row.
+        def checkbox_item_part(**options, &)
+          checked = options.delete(:checked) || false
+          shortcut = options.delete(:shortcut)
+          attrs = {
+            "data-slot" => "#{family_slot_prefix}-checkbox-item", "role" => "menuitemcheckbox", "tabindex" => "-1",
+            "data-poetry-collection-item" => "",
+            # aria-checked and the data-checked/data-unchecked pair written
+            # TOGETHER, never separately.
+            "aria-checked" => checked.to_s, (checked ? "data-checked" : "data-unchecked") => "",
+            "class" => family_style.css(:checkbox_item, class: options.delete(:class))
+          }.merge(item_action_attributes)
+          apply_item_flags(attrs, **options.extract!(:disabled, :text_value, :close_on_select))
+          content_tag(:div, Poetry::Core::HTML::Attributes.merged(attrs, options)) do
+            safe_join([item_indicator(:check, family_style.css(:indicator_check), :checkbox),
+                       capture(&), shortcut_span(shortcut)].compact)
+          end
+        end
+
+        # Builds the non-interactive heading row.
+        def label_part(inset: false, **options, &)
+          attrs = {
+            "data-slot" => "#{family_slot_prefix}-label",
+            "class" => family_style.css(:label, class: options.delete(:class))
+          }
+          attrs["data-inset"] = "true" if inset
+          content_tag(:div, Poetry::Core::HTML::Attributes.merged(attrs, options)) { capture(&) }
+        end
+
+        # Builds the role=separator rule.
+        def separator_part(**options)
+          attrs = {
+            "data-slot" => "#{family_slot_prefix}-separator", "role" => "separator",
+            "aria-orientation" => "horizontal",
+            "class" => family_style.css(:separator, class: options.delete(:class))
+          }
+          content_tag(:div, nil, Poetry::Core::HTML::Attributes.merged(attrs, options))
+        end
+      end
+
+      # role=group semantic grouping between separators - the same item
+      # union, one level down.
+      #
+      # @api private
+      class Group < Poetry::Core::Component
+        internal_component!
+        include ItemSlots
+
+        def initialize(dir: nil, **extra_attributes)
+          super(extra_attributes)
+          @dir = dir
+        end
+
+        def before_render
+          raise ArgumentError, "#{family_name} group requires at least one item" unless items?
+        end
+
+        def call
+          attrs = { "data-slot" => "#{family_slot_prefix}-group", "role" => "group" }
+          content_tag(:div, Poetry::Core::HTML::Attributes.merged(attrs, html_attributes)) { safe_join(items.map(&:to_s)) }
+        end
+
+        private
+
+        def menu_dir
+          @dir
+        end
+      end
+
+      # role=group scoping the single-select value for its radio items -
+      # radio items exist only through this group; duplicate values raise.
+      #
+      # @api private
+      class RadioGroup < Poetry::Core::Component
+        internal_component!
+        include Helpers
+
+        attr_reader :group_value
+
+        renders_many :radio_items,
+                     doc: "One role=menuitemradio row; value: must be unique within the group.",
+                     renders: lambda { |value:, disabled: false, text_value: nil,
+                                            close_on_select: nil, shortcut: nil, **options, &block|
+                       key = value.to_s
+                       unless @seen_values.add?(key)
+                         raise ArgumentError, "duplicate #{family_name} radio value #{key.inspect} - values must be " \
+                                              "unique within their radio group"
+                       end
+
+                       checked = !group_value.nil? && key == group_value
+                       attrs = {
+                         "data-slot" => "#{family_slot_prefix}-radio-item", "role" => "menuitemradio",
+                         "tabindex" => "-1", "data-poetry-collection-item" => "", "data-value" => key,
+                         "aria-checked" => checked.to_s, (checked ? "data-checked" : "data-unchecked") => "",
+                         "class" => family_style.css(:radio_item, class: options.delete(:class))
+                       }.merge(item_action_attributes)
+                       apply_item_flags(attrs, disabled:, text_value:, close_on_select:)
+                       content_tag(:div, Poetry::Core::HTML::Attributes.merged(attrs, options)) do
+                         safe_join([item_indicator(:circle, family_style.css(:indicator_circle), :radio),
+                                    capture(&block), shortcut_span(shortcut)].compact)
+                       end
+                     }
+
+        def initialize(value: nil, **extra_attributes)
+          super(extra_attributes)
+          @group_value = value&.to_s
+          @seen_values = Set.new
+        end
+
+        def before_render
+          raise ArgumentError, "#{family_name} radio group requires at least one with_radio_item" unless radio_items?
+        end
+
+        def call
+          attrs = { "data-slot" => "#{family_slot_prefix}-radio-group", "role" => "group" }
+          attrs["data-value"] = group_value if group_value
+          content_tag(:div, Poetry::Core::HTML::Attributes.merged(attrs, html_attributes)) { safe_join(radio_items.map(&:to_s)) }
+        end
+      end
+
+      # A submenu scope - its own positioning instance (trigger anchors
+      # content; side flips under RTL) around the same item union, recursively.
+      #
+      # @api private
+      class Sub < Poetry::Core::Component
+        internal_component!
+        include ItemSlots
+
+        renders_one :trigger,
+                    doc: "role=menuitem in the PARENT's collection + aria wiring to its own sub-content; the " \
+                         "trailing chevron ships built in (flips via logical ml-auto under RTL).",
+                    renders: lambda { |inset: false, disabled: false, text_value: nil, **options, &block|
+                      attrs = {
+                        "id" => trigger_id, "data-slot" => "#{family_slot_prefix}-sub-trigger", "role" => "menuitem",
+                        "tabindex" => "-1", "data-poetry-collection-item" => "",
+                        "aria-haspopup" => "menu", "aria-expanded" => "false", "aria-controls" => content_id,
+                        "class" => family_style.css(:sub_trigger, class: options.delete(:class))
+                      }.merge(sub_trigger_stimulus_attributes)
+                      apply_item_flags(attrs, inset:, disabled:, text_value:)
+                      content_tag(:div, Poetry::Core::HTML::Attributes.merged(attrs, options)) do
+                        safe_join([capture(&block), chevron])
+                      end
+                    }
+
+        def initialize(dir: nil, **extra_attributes)
+          super(extra_attributes)
+          @dir = dir
+        end
+
+        def before_render
+          raise ArgumentError, "#{family_name} sub requires with_trigger (the sub-menu item)" unless trigger?
+          raise ArgumentError, "#{family_name} sub requires at least one item" unless items?
+        end
+
+        def call
+          content_tag(:div, sub_attributes) { safe_join([trigger, sub_content]) }
+        end
+
+        def trigger_id
+          "#{instance_id}-trigger"
+        end
+
+        def content_id
+          "#{instance_id}-content"
+        end
+
+        private
+
+        def menu_dir
+          @dir
+        end
+
+        def rtl?
+          @dir == :rtl
+        end
+
+        def instance_id
+          @instance_id ||= poetry_instance_id("poetry-#{family_slot_prefix}-sub")
+        end
+
+        def sub_attributes
+          attrs = { "data-slot" => "#{family_slot_prefix}-sub" }.merge(
+            stimulus_attributes(:popper) do |popper|
+              popper.register_controller
+              popper.with_value(:side, rtl? ? :left : :right)
+              popper.with_value(:align, :start)
+            end
+          )
+          Poetry::Core::HTML::Attributes.merged(attrs, html_attributes)
+        end
+
+        def sub_content
+          attrs = {
+            "id" => content_id, "role" => "menu", "aria-orientation" => "vertical",
+            "aria-labelledby" => trigger_id, "tabindex" => "-1",
+            "data-slot" => "#{family_slot_prefix}-sub-content", "data-closed" => "", "hidden" => true,
+            "class" => family_style.css(:sub_content)
+          }.merge(stimulus_attributes(:popper) { |popper| popper.with_target(:content) })
+          content_tag(:div, attrs) { safe_join(items.map(&:to_s)) }
+        end
+
+        def sub_trigger_stimulus_attributes
+          stimulus_attributes(:menu, :popper) do |menu, popper|
+            menu.with_action(:sub_enter, on: :pointerenter)
+            menu.with_action(:sub_leave, on: :pointerleave)
+            menu.with_action(:open_sub, on: :click)
+            popper.with_target(:anchor)
+          end
+        end
+
+        def chevron
+          render(Icon::Component.new(name: :"chevron-right", class: family_style.css(:sub_indicator)))
+        end
+      end
+    end
+  end
+end

data/app/components/poetry/ui/message/component.html.erb

@@ -0,0 +1,8 @@
+<%= content_tag(:div, **root_attributes.to_attributes) do %>
+  <% if avatar? %><div data-slot="message-avatar" class="<%= css(:avatar) %>"><%= avatar %></div><% end %>
+  <div data-slot="message-content" class="<%= css(:content) %>">
+    <% if header? %><div data-slot="message-header" class="<%= css(:header) %>"><%= header %></div><% end %>
+    <%= content %>
+    <% if footer? %><div data-slot="message-footer" class="<%= css(:footer) %>"><%= footer %></div><% end %>
+  </div>
+<% end %>

data/app/components/poetry/ui/message/component.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Poetry
+  module Ui
+    # One chat turn's row in a conversation transcript.
+    module Message
+      # One chat turn's row: an avatar beside a content column of
+      # header, message bubbles (the body block), and footer. align:
+      # :end mirrors the row for the local user's side. Purely
+      # presentational - no JavaScript.
+      #
+      # @example
+      #   render Poetry::Ui::Message::Component.new do |message|
+      #     message.with_avatar { "AI" }
+      #     message.with_header { "Assistant" }
+      #     tag.div("Here's the plan for today.")
+      #   end
+      class Component < Poetry::Core::Component
+        # The closed vocabulary for the align axis.
+        ALIGNS = %i[start end].freeze
+
+        # Projected into the registry, llms.txt, and the agent surface.
+        AGENT_RULES = [
+          "One Message per turn: avatar slot + header/footer slots; the body block holds the Bubbles.",
+          "align: :end is the local user's side - set it on the Message, never on the Bubbles inside.",
+          "The avatar slot is decorative context by default - pass meaningful sender identity in the header.",
+          "Timestamps and delivery state belong in the footer slot (it lifts the avatar automatically)."
+        ].freeze
+
+        renders_one :avatar, doc: "The sender's avatar, kept beside the content column - decorative context; put " \
+                                  "meaningful sender identity in the header."
+        renders_one :header, doc: "The sender identity line above the bubbles."
+        renders_one :footer, doc: "Timestamps / delivery state below the bubbles."
+
+        option :align, :symbol, default: :start,
+                                doc: "Which side the row sits on; :end mirrors it for the local user's side."
+
+        validates :align, inclusion: { in: ALIGNS }
+
+        part "message", "The chat-row root - avatar plus a content column; align: :end " \
+                        "mirrors the row for the local user's side",
+             states: {
+               "data-align" => { condition: "always - the resolved align",
+                                 values: ALIGNS.map(&:to_s) }
+             }
+        part "message-avatar", "The avatar slot's box, kept out of the content column"
+        part "message-content", "The content column - header, the body block (the Bubbles), " \
+                                "footer"
+        part "message-header", "Sender identity line above the bubbles (header slot)"
+        part "message-footer", "Timestamps / delivery state below the bubbles (footer slot - " \
+                               "it lifts the avatar)"
+
+        # @api private
+        def root_attributes
+          html_attributes.merge_if_not_set(
+            { "data-slot" => "message", "data-align" => align }.merge(component_data_attributes)
+          )
+        end
+
+        private :root_attributes
+      end
+    end
+  end
+end

data/app/components/poetry/ui/message/preview.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Poetry
+  module Ui
+    module Message
+      # The Message preview matrix.
+      class Preview < Poetry::Core::Preview::Base
+        def default
+          render_component do |message|
+            message.with_avatar { "AI" }
+            message.with_header { "Assistant" }
+            tag.div("Here's the plan for today.", class: "rounded-xl bg-muted px-3 py-2 w-fit")
+          end
+        end
+
+        def align_end
+          render_component(align: :end) do |message|
+            message.with_footer { "Read 10:42" }
+            tag.div("Sounds good!", class: "rounded-xl bg-primary text-primary-foreground px-3 py-2 w-fit")
+          end
+        end
+
+        def with_footer_lifts_avatar
+          render_component do |message|
+            message.with_avatar { "AI" }
+            message.with_footer { "10:41" }
+            tag.div("Footer present - the avatar lifts.", class: "rounded-xl bg-muted px-3 py-2 w-fit")
+          end
+        end
+      end
+    end
+  end
+end

data/app/components/poetry/ui/message/style.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Poetry
+  module Ui
+    module Message
+      # Re-expressed through the cn-* theme layer. The :has()/group
+      # context choreography stays inline (footer presence lifts the
+      # avatar; the align axis flips rows and self-alignment); type,
+      # spacing, and the ghost-Bubble padding collapse ride the theme.
+      class Style < Poetry::Core::Style
+        base "cn-message group/message relative flex w-full min-w-0 data-[align=end]:flex-row-reverse"
+
+        element :group, "cn-message-group flex min-w-0 flex-col"
+
+        element :avatar, "cn-message-avatar flex w-fit shrink-0 items-center justify-center self-end " \
+                         "overflow-hidden rounded-full bg-muted " \
+                         "group-has-data-[slot=message-footer]/message:-translate-y-8"
+
+        element :content, "cn-message-content flex w-full min-w-0 flex-col wrap-break-word " \
+                          "group-data-[align=end]/message:*:data-slot:self-end"
+
+        element :header, "cn-message-header flex max-w-full min-w-0 items-center"
+
+        element :footer, "cn-message-footer flex max-w-full min-w-0 items-center " \
+                         "group-data-[align=end]/message:justify-end"
+      end
+    end
+  end
+end

data/app/components/poetry/ui/message_scroller/component.html.erb

@@ -0,0 +1,15 @@
+<%= content_tag(:div, **root_attributes.to_attributes) do %>
+  <div <%= tag.attributes(viewport_attributes) %>>
+    <div <%= tag.attributes(content_attributes) %>>
+      <%= content %>
+      <div <%= tag.attributes(spacer_attributes) %>></div>
+    </div>
+  </div>
+  <% if jump_button %>
+    <%= render Poetry::Ui::Button::Component.new(variant: :secondary, size: :"icon-sm",
+                                                 label: t("poetry.message_scroller.scroll_to_end"),
+                                                 **button_attributes) do %>
+      <%= render Poetry::Ui::Icon::Component.new(name: :"arrow-down") %>
+    <% end %>
+  <% end %>
+<% end %>