plutonium 0.62.2 → 0.64.0

data/lib/plutonium/ui/component/methods.rb

@@ -31,6 +31,8 @@ module Plutonium
           :resource_class,
           :resource_record!,
           :resource_record?,
+          :singular_resource_context?,
+          :singular_resource_route_for?,
           :resource_name,
           :resource_name_plural,
           :nestable_resource_name_plural,
@@ -48,6 +50,7 @@ module Plutonium
           :in_frame?,
           :in_modal?,
           :in_secondary_modal?,
+          :in_kanban_modal?,
           :turbo_scoped_dom_id,
           :current_interactive_action,
           :current_engine,
@@ -58,6 +61,8 @@ module Plutonium
           :root_path,
           :make_page_title,
           :resource_logo_tag,
+          :current_page_path,
+          :current_page_url,
           to: :view_context
       end
     end

data/lib/plutonium/ui/component/positionable.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module Plutonium
+  module UI
+    module Component
+      # Drag-to-reorder plumbing shared by every index surface that renders a
+      # collection of a `position_on` resource — the table (Table::Resource) and
+      # the card grid (Grid::Resource).
+      #
+      # Extracted rather than copied because the two halves of this feature have
+      # to agree EXACTLY: the client only offers a drag under the same condition
+      # the server accepts one, and the URL template the client substitutes into
+      # has to be the collection's own path. Two copies of that reasoning is two
+      # places for the client and the server to drift apart.
+      #
+      # A host must supply `resource_definition`, `current_query_object`,
+      # `current_page_path` and `policy_for` — everything Component::Base's
+      # index views already have.
+      module Positionable
+        private
+
+        # The resource's positioning strategy, or nil when it declares none /
+        # declares `position_on false`. Everything else here hangs off this.
+        def position_config
+          return @position_config if defined?(@position_config)
+
+          config = resource_definition.defined_position_config
+          @position_config = (config && !config.disabled?) ? config : nil
+        end
+
+        # Whether a drop can be honoured RIGHT NOW.
+        #
+        # Dropping "between the two records either side of me" only describes a
+        # position when the visual order IS the stored order. Under a title sort
+        # the neighbours say nothing; under a DESCENDING position sort they say
+        # the opposite of what the write would assume. The server rejects both
+        # (422, no write) — this is the client half of that same rule, and it
+        # deliberately reuses the server's own predicate rather than restating it.
+        def position_drag_enabled?
+          return false unless position_config
+
+          current_query_object.sorted_ascending_only_by?(position_config.attribute)
+        end
+
+        # The URL that puts the collection back into ascending position order —
+        # what the disabled grip links to. Built off the registered sort (see
+        # Definition::Positioning#position_on), which flips to ASC from a
+        # descending position sort and starts at ASC from any other sort.
+        def position_sort_url
+          current_query_object.sort_params_for(position_config.attribute)[:url]
+        end
+
+        # What to hand a grip: nil while dragging is live, otherwise the sort URL
+        # that makes it live. Memoized because it depends on the collection's
+        # sort, not on the record — re-deriving it per row would rebuild the same
+        # URL for every row of every page.
+        def position_grip_sort_url
+          return @position_grip_sort_url if defined?(@position_grip_sort_url)
+
+          @position_grip_sort_url = position_drag_enabled? ? nil : position_sort_url
+        end
+
+        # The member reposition path with an __ID__ placeholder for the client to
+        # substitute. Mirrors Kanban::Resource#kanban_move_url_template, but off
+        # `current_page_path` rather than `request.path`: after a rebalance the
+        # endpoint re-renders this very collection from a POST to
+        # /things/5/reposition, and a template derived from THAT request would
+        # send every subsequent drop to a nested path that does not exist.
+        def position_url_template
+          "#{current_page_path.delete_suffix("/")}/__ID__/reposition"
+        end
+
+        # Whether THIS viewer may reorder THIS record. Has to run per record —
+        # it is what keeps someone who may not reorder a given record from being
+        # offered a grip that can only ever answer 403.
+        def repositionable?(record)
+          policy_for(record:).allowed_to?(:reposition?)
+        end
+
+        # Which positioning GROUP a record sits in, or nil when every record on
+        # the surface shares one list.
+        #
+        # A scoped resource (`positioned_on :position, scope: :product_id`) keeps
+        # an independent 1..n sequence per group, so a top-level index that spans
+        # groups interleaves several sequences. A drop between two records from
+        # DIFFERENT groups describes no position at all, and the server refuses
+        # it (see PositionActions#resolve_position_neighbour, which rejects a
+        # neighbour whose scope attribute differs). This is the client half of
+        # that same rule — the value goes on the row so the drag can refuse
+        # before the user commits, instead of snapping back afterwards.
+        #
+        # Guarded on `delegate?` exactly as the server is: Mode B owns its own
+        # notion of a group, and nothing out here may second-guess it.
+        def position_group_for(record)
+          return nil unless position_config&.delegate?
+
+          attr = record.class.positioning_scope_attr
+          attr && record[attr]
+        end
+
+        # Passed to the collection components, which have no access to the
+        # definition and must not grow any. nil when the resource is unscoped, so
+        # the attribute is omitted entirely rather than emitted empty.
+        def position_group_resolver
+          return nil unless position_config&.delegate?
+
+          method(:position_group_for)
+        end
+      end
+    end
+  end
+end

data/lib/plutonium/ui/component/resolves_tags.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Plutonium
+  module UI
+    module Component
+      # Turns a resolved `as:` into a component, for every surface that renders a
+      # field: forms, displays, tables, filter forms and the wizard summary.
+      #
+      # `as:` is a union — a built-in alias (Symbol/String, dispatched to the
+      # builder's `#{alias}_tag` method) or a component Class rendered directly
+      # (see {Plutonium::Definition::InputAliases}). Every surface has to handle
+      # BOTH, so the branch lives here instead of being re-implemented per view —
+      # a table or filter form that hand-rolled only the alias half raised
+      # `NoMethodError: MyPickerComponent_tag` on an `as:` a form rendered
+      # happily.
+      #
+      # A component Class is instantiated with the field builder (the contract
+      # every built-in tag component follows), so `as:` takes FIELD components; a
+      # component with its own constructor goes through the block form
+      # (`input :x do |field| MyComponent.new(value: field.value) end`).
+      #
+      # Mixed into the form and display field builders, so it is available on
+      # every `f` a view yields (including the table's display builder).
+      module ResolvesTags
+        # @param tag [Symbol, String, Class, nil] a built-in alias, a component
+        #   class, or nil to infer the tag from the field's type.
+        # @param attributes [Hash] tag attributes. Reach a component class the
+        #   same way they reach an alias tag — via `Components::Base#attributes`
+        #   — so `as:` declarations honour the surface's own attributes (the
+        #   filter panel's `class: "w-full"`, a form's `pre_submit` action)
+        #   instead of silently dropping them.
+        # @return [Phlex::SGML] the component to render.
+        def component_for(tag, **attributes, &)
+          tag ||= inferred_field_component
+          return create_component(tag, component_theme_key(tag), **attributes, &) if tag.is_a?(Class)
+
+          send(:"#{tag}_tag", **attributes, &)
+        end
+
+        private
+
+        # Theme key for a directly-rendered component class:
+        # `Admin::ColorPickerComponent` themes off `:color_picker`.
+        #
+        # The `_?` matters — dropping a bare `component$` left the separator
+        # behind, so the key was `:color_picker_` and a theme entry written for
+        # the obvious `:color_picker` silently never matched. Nothing in the
+        # framework keys off this (built-in tags pass their key to
+        # `create_component` explicitly); it is reached only for a user's `as:`
+        # class, which is exactly the case that was broken.
+        def component_theme_key(component_class)
+          component_class.name.demodulize.underscore.sub(/_?component$/, "").to_sym
+        end
+      end
+    end
+  end
+end

data/lib/plutonium/ui/component/section.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+module Plutonium
+  module UI
+    module Component
+      # Shared chrome for a declared layout section — a card with a header row
+      # (accent bar, heading, optional description, optional collapse caret)
+      # over a body that holds the fields. Subclassed (not copied) by both
+      # {Plutonium::UI::Form::Components::Section} and
+      # {Plutonium::UI::Display::Components::Section} so a form section and a
+      # show-page section always read the same; the only difference between the
+      # two is which grid class the caller passes in.
+      #
+      # Each section is its OWN card rather than a band inside one shared card.
+      # The card boundary does the grouping — no amount of heading typography
+      # separates two field groups as unambiguously as an actual edge does, and
+      # the header row then only has to name the group rather than carry the
+      # whole structural signal. Callers therefore must NOT wrap sections in a
+      # card of their own; they supply a plain stacking container.
+      #
+      # The caller supplies the fields as a block and owns what a "field" means.
+      class Section < Plutonium::UI::Component::Base
+        # Default section chrome, merged into BOTH Form::Theme and
+        # Display::Theme so the two read identically out of the box while each
+        # stays independently overridable — the same contract every other
+        # themed key has. Defined here rather than written out twice so the
+        # shipped defaults cannot drift between the form and the show page.
+        #
+        # Structure (which element gets which key, the `group`/[open]
+        # mechanics) stays in this component; themes own the classes.
+        DEFAULT_THEME = {
+          # Merged into the section's {Plutonium::UI::Block} card — Block
+          # supplies `pu-card` itself, so this only adds what is specific to a
+          # section. `overflow-hidden` keeps the header row's fill and border
+          # inside the card's rounded corners.
+          section_wrapper: "overflow-hidden",
+
+          # Header row. Its bottom border is the line between the header and
+          # the fields — the card edge already separates one section from the
+          # next, so nothing else has to.
+          section_header:
+            "px-4 py-3 flex items-center gap-3 " \
+            "border-b border-[var(--pu-border)] bg-[var(--pu-surface-alt)]",
+
+          # A short primary bar at the head of the row. A standalone element
+          # rather than a border on the text block, so the heading and its
+          # description stay vertically centred against it.
+          section_accent: "shrink-0 w-1 h-5 rounded-full bg-primary-500",
+
+          # Sized to sit under the page title (text-xl semibold) while
+          # out-ranking display values (text-lg regular) and field labels.
+          # With the card doing the separating, the heading no longer has to
+          # shout to be read as a header.
+          section_heading: "text-base font-bold tracking-tight text-[var(--pu-text)]",
+          section_description: "text-sm font-normal text-[var(--pu-text-muted)]",
+
+          # `list-none` + the WebKit marker reset remove the native disclosure
+          # triangle, which the browser pins to the LEFT of the summary — where
+          # it would displace the accent bar and knock the heading out of the
+          # alignment every other section keeps. The caret is re-drawn on the
+          # right instead, so headers stay identical whether or not a section
+          # happens to be collapsible.
+          # The divider only exists to separate the header from the fields, so
+          # a COLLAPSED section must not draw one — there is nothing below it,
+          # and the line would land directly on the card's own bottom border.
+          # `group-open:` keys it to the parent <details>'s [open] state.
+          section_summary:
+            "px-4 py-3 flex items-center gap-3 cursor-pointer select-none " \
+            "border-b-0 group-open:border-b border-[var(--pu-border)] " \
+            "bg-[var(--pu-surface-alt)] " \
+            "list-none [&::-webkit-details-marker]:hidden",
+
+          section_caret:
+            "shrink-0 w-3 h-3 text-[var(--pu-text-muted)] " \
+            "transition-transform duration-200 group-open:rotate-180",
+
+          # Padding box between the card edge and the field grid. Roomier than
+          # the stock `pu-card-body` (16px): a section card holds inputs, not
+          # the dense label/value rows a card body is sized for, and the form
+          # this replaced was a single `p-8` card — at 16px the fields sit
+          # noticeably tighter against the edge than they used to.
+          section_body: "p-6"
+        }.freeze
+
+        # The theme this section's chrome resolves against. Subclasses name
+        # their own, so a form section follows Form::Theme and a show-page
+        # section follows Display::Theme.
+        def self.theme_class
+          raise NotImplementedError, "#{self} must implement .theme_class"
+        end
+
+        def initialize(resolved, grid_class:)
+          @section = resolved.section
+          @grid_class = grid_class
+        end
+
+        # Every section is a {Plutonium::UI::Block} — the shared card primitive
+        # — so a section card and any other card on the page are the same
+        # surface by construction rather than by two lists of classes that
+        # happen to agree today.
+        def view_template(&fields_block)
+          Block(class: themed_section(:section_wrapper)) do
+            if @section.collapsible?
+              # `group` lets the caret rotate off the <details>'s [open] state.
+              details(open: !@section.collapsed?, class: "group") do
+                # <summary> must be the first child of <details> and can't be
+                # wrapped, so it IS the header row.
+                summary(class: themed_section(:section_summary)) do
+                  span(class: themed_section(:section_accent))
+                  heading_block
+                  render_caret
+                end
+                body(&fields_block)
+              end
+            else
+              header_row
+              body(&fields_block)
+            end
+          end
+        end
+
+        private
+
+        def themed_section(key)
+          self.class.theme_class.instance.resolve_theme(key)
+        end
+
+        # An unlabelled `ungrouped` bucket gets no header row at all — just a
+        # card holding its leftover fields.
+        def header_row
+          return if headerless?
+          div(class: themed_section(:section_header)) do
+            span(class: themed_section(:section_accent))
+            heading_block
+          end
+        end
+
+        def headerless? = @section.ungrouped? && @section.options[:label].nil?
+
+        # Title over description, taking the free space in the row so the caret
+        # is pushed to the far right.
+        def heading_block
+          div(class: "min-w-0 flex-1") do
+            h3(class: themed_section(:section_heading)) { heading_text }
+            describe
+          end
+        end
+
+        def heading_text = @section.label
+
+        def describe
+          return unless @section.description
+          p(class: themed_section(:section_description)) { @section.description }
+        end
+
+        # Points down when open, up when closed (rotate-180). Decorative — the
+        # <summary> element already carries the expand/collapse semantics for
+        # assistive tech, so this is aria-hidden.
+        def render_caret
+          svg(
+            class: themed_section(:section_caret),
+            aria_hidden: "true",
+            xmlns: "http://www.w3.org/2000/svg",
+            fill: "none",
+            viewbox: "0 0 10 6"
+          ) do |s|
+            s.path(
+              stroke: "currentColor",
+              stroke_linecap: "round",
+              stroke_linejoin: "round",
+              stroke_width: "2",
+              d: "M1 1l4 4 4-4"
+            )
+          end
+        end
+
+        def body(&fields_block)
+          div(class: themed_section(:section_body)) do
+            div(class: @grid_class, &fields_block)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/plutonium/ui/display/base.rb

@@ -8,6 +8,7 @@ module Plutonium
 
         class Builder < Builder
           include Plutonium::UI::Display::Options::InferredTypes
+          include Plutonium::UI::Component::ResolvesTags
 
           def association_tag(**, &)
             create_component(Plutonium::UI::Display::Components::Association, :association, **, &)
@@ -26,6 +27,13 @@ module Plutonium
             create_component(Plutonium::UI::Display::Components::PhlexiRender, :phlexi_render, **, &)
           end
 
+          # Themed as :string so a formatted value looks identical to any other
+          # string field (same wrapper + text-lg), just with the value passed
+          # through the `formatter:` proc.
+          def formatted_value_tag(**, &)
+            create_component(Plutonium::UI::Display::Components::FormattedValue, :string, **, &)
+          end
+
           def boolean_tag(**, &)
             create_component(Plutonium::UI::Display::Components::Boolean, :boolean, **, &)
           end
@@ -53,8 +61,12 @@ module Plutonium
 
         private
 
+        # A card (the shared {Plutonium::UI::Block} primitive) around the field
+        # grid. Block owns what a card IS — surface, border, radius, shadow —
+        # so callers just ask for a fields_wrapper and cannot end up with a
+        # card that disagrees with the ones beside it.
         def fields_wrapper(&)
-          div(class: themed(:fields_wrapper)) {
+          render Plutonium::UI::Block.new(class: themed(:fields_wrapper)) {
             div(class: themed(:fields_inner)) {
               yield
             }

data/lib/plutonium/ui/display/components/formatted_value.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Plutonium
+  module UI
+    module Display
+      module Components
+        # Renders a value transformed by a user-supplied `formatter:` proc, themed
+        # like a plain string. `formatter:` is a general column/display option, but
+        # only the string component ever consumed it — handed to a typed component
+        # (boolean pill, currency, badge…) the Proc leaked into the element's HTML
+        # attributes and Phlex rejected it. The resource/table render layers route
+        # every formatter-bearing field here instead.
+        #
+        # Unlike Phlexi's String component — which stringifies the value *before*
+        # the formatter runs (so a boolean `false` would arrive as the truthy
+        # string "false") — this keeps the raw value, matching the documented
+        # contract that a formatter "receives just the value".
+        class FormattedValue < Phlexi::Display::Components::String
+          # Keep the raw value so the formatter sees a real boolean / number /
+          # object rather than its `to_s`.
+          def normalize_value(value) = value
+        end
+      end
+    end
+  end
+end

data/lib/plutonium/ui/display/components/section.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Plutonium
+  module UI
+    module Display
+      module Components
+        # A show page's declared `display_layout` section. All chrome lives in
+        # the shared {Plutonium::UI::Component::Section} so a show-page section
+        # and a form section cannot drift apart; the display contributes only
+        # its grid class (the themed :section_grid) and the block that renders
+        # the fields.
+        class Section < Plutonium::UI::Component::Section
+          def self.theme_class = Plutonium::UI::Display::Theme
+        end
+      end
+    end
+  end
+end

data/lib/plutonium/ui/display/resource.rb

@@ -35,27 +35,143 @@ module Plutonium
           present_associations? && resource_associations.present?
         end
 
+        # Stacked in `sections_wrapper` — the hooks and the fields card each
+        # own their own card with no margin, so an override that renders one
+        # (e.g. Async::RunDefinition's progress panel) would otherwise butt flush
+        # against the fields card.
         def render_fields
-          if metadata_fields.any?
-            div(class: "grid grid-cols-1 lg:grid-cols-[minmax(0,1fr)_320px] gap-6 items-start") do
-              div { render_main_field_card }
-              aside { render_metadata_panel }
-            end
-          else
-            render_main_field_card
+          div(class: themed(:sections_wrapper)) do
+            render_before_fields
+            render_default_fields
+            render_after_fields
+          end
+        end
+
+        # Hooks for content that belongs to the Details tab alone. render_fields
+        # is the tab body when associations exist, and the whole display when
+        # they don't, so these fire in the Details context either way and never
+        # in an association tab. The page-level render_before_content /
+        # render_after_content hooks sit outside the tablist and would show
+        # regardless of the active tab.
+        def render_before_fields
+        end
+
+        def render_after_fields
+        end
+
+        def render_default_fields
+          # Inside a kanban card's modal we render a compact detail: no metadata
+          # at all. render_main_field_card already subtracts metadata_fields, so
+          # those fields stay hidden rather than folding into the main card.
+          return render_main_field_card if metadata_fields.none? || in_kanban_modal?
+
+          # In a (non-kanban) modal the metadata stacks BELOW the details
+          # instead of beside them. The rail is a fixed 320px column and its
+          # `lg:` breakpoint is a viewport query, so it would split inside the
+          # dialog no matter how narrow the dialog is — leaving the main column
+          # crushed against it. Stacking sidesteps that entirely, and means the
+          # dialog does not have to grow just to hold a rail.
+          if in_modal?
+            # A stacking container, not two bare siblings: the cards carry no
+            # margin of their own, so without it they butt straight up against
+            # each other with no seam between the details and the metadata.
+            return div(class: themed(:sections_wrapper)) {
+              render_main_field_card
+              render_metadata_panel
+            }
+          end
+
+          div(class: "grid grid-cols-1 lg:grid-cols-[minmax(0,1fr)_320px] gap-6 items-start") do
+            div { render_main_field_card }
+            aside { render_metadata_panel }
           end
         end
 
         def render_main_field_card
-          Block do
-            fields_wrapper do
-              # Skip fields claimed by the metadata panel — rendering
-              # them in both places duplicates information.
-              (resource_fields - metadata_fields).each do |name|
-                render_resource_field name
-              end
+          # Skip fields claimed by the metadata panel — rendering them in both
+          # places duplicates information.
+          fields = resource_fields - metadata_fields
+          sections = resolve_display_layout(fields)
+
+          # Unsectioned: one card holding one grid. fields_wrapper is itself a
+          # Block now, so this is the same card primitive the sections and the
+          # metadata panel use.
+          if sections.nil?
+            return fields_wrapper do
+              fields.each { |name| render_resource_field name }
             end
           end
+
+          # Sectioned: each section is its own card, so there is deliberately
+          # no Block/card wrapper here — one would nest cards inside a card.
+          div(class: themed(:sections_wrapper)) do
+            sections.each { |rs| render_display_section(rs) }
+          end
+        end
+
+        # Resolve the whole display layout for THIS render: drop
+        # condition-hidden sections and sections left with no fields (e.g.
+        # every declared field was filtered out by the permitted set).
+        # Returns nil when no display_layout is declared (caller falls back
+        # to a single grid).
+        def resolve_display_layout(fields)
+          sections = resource_definition.resolve_display_sections(fields)
+          return nil if sections.nil?
+
+          sections.filter_map do |resolved|
+            section = resolved.section
+            condition = section.condition
+            next if condition && !instance_exec(&condition)
+            next if resolved.fields.empty?
+
+            Plutonium::Definition::FormLayout::ResolvedSection.new(
+              section: Plutonium::Definition::FormLayout::Section.new(
+                key: section.key,
+                fields: section.fields,
+                options: resolve_section_option_procs(section.options).freeze
+              ),
+              fields: resolved.fields
+            )
+          end
+        end
+
+        # Resolve proc-valued section options for THIS render, by the same
+        # arity rule the form uses (Form::Resource#resolve_option_procs): a
+        # zero-arity proc is called plainly and keeps its own binding, while a
+        # one-arity proc is handed this display for `object`/`params`/helpers.
+        #
+        # Without this a `collapsed: -> { ... }` would reach the component as
+        # the Proc itself, and `collapsed?` — a plain `!!` — would be true no
+        # matter what the proc returns, silently pinning the section shut.
+        #
+        # `condition:` is excluded for the same reason it is on the form: it
+        # asks "should this render here, now?", which is resolved separately
+        # and against this display, not turned into a value up front.
+        def resolve_section_option_procs(options)
+          return options if options.blank?
+
+          options.to_h do |key, value|
+            resolvable = key != :condition && value.is_a?(Proc)
+            next [key, value] unless resolvable
+
+            [key, value.arity.zero? ? value.call : value.call(self)]
+          end
+        end
+
+        # Pure presentation — the section is already resolved (visible) by
+        # resolve_display_layout.
+        # Every section renders into the SAME responsive grid (themed
+        # :section_grid, which matches the unsectioned path's :fields_inner
+        # minus the padding its wrapper now owns). display_layout groups
+        # fields; it does not resize them — that stays a per-field concern,
+        # via `display :x, wrapper: {class: "col-span-2"}`, which works
+        # identically inside a section and outside one.
+        def render_display_section(resolved)
+          render Plutonium::UI::Display::Components::Section.new(
+            resolved, grid_class: themed(:section_grid)
+          ) do
+            resolved.fields.each { |name| render_resource_field name }
+          end
         end
 
         # Renders the declared metadata fields as a vertical stack beside
@@ -64,6 +180,9 @@ module Plutonium
         # only difference from the main card is the wrapper — a single
         # column of fields instead of the form's multi-column grid.
         def render_metadata_panel
+          # Same card primitive as the details card(s) beside it, so the two
+          # sit on one surface — this panel used to be a borderless,
+          # heavier-shadowed Block and read as a different kind of thing.
           Block do
             div(class: "pu-card-body flex flex-col gap-6") do
               metadata_fields.each { |name| render_resource_field(name) }
@@ -189,14 +308,14 @@ module Plutonium
             field_options = field_options.merge(field_level_options)
 
             tag_attributes = display_options.except(:wrapper, :as, :condition, *field_level_keys)
-            tag_block = display_definition[:block] || ->(f) {
-              tag ||= f.inferred_field_component
-              if tag.is_a?(Class)
-                f.send :create_component, tag, tag.name.demodulize.underscore.sub(/component$/, "").to_sym
-              else
-                f.send(:"#{tag}_tag", **tag_attributes)
-              end
-            }
+
+            # A `formatter:` produces the display string itself, so render it
+            # through the formatted-value component regardless of the field's
+            # type. Otherwise the Proc would be handed to a typed component
+            # (boolean pill, currency…) and leak into its HTML attributes.
+            tag = :formatted_value if tag_attributes.key?(:formatter)
+
+            tag_block = display_definition[:block] || ->(f) { f.component_for(tag, **tag_attributes) }
 
             wrapper_options = display_options[:wrapper] || {}