plutonium 0.60.5 → 0.62.0

data/lib/plutonium/ui/grid/card.rb

@@ -8,18 +8,24 @@ module Plutonium
       # `grid_fields` on the resource definition. Each slot is optional;
       # `header` falls back to `record.to_label` when undeclared.
       class Card < Plutonium::UI::Component::Base
-        attr_reader :record, :resource_definition, :resource_fields
+        attr_reader :record, :resource_definition, :resource_fields, :card_fields
 
-        def initialize(record, resource_definition:, resource_fields: nil)
+        def initialize(record, resource_definition:, resource_fields: nil, card_fields: nil, show_turbo_frame: nil)
           @record = record
           @resource_definition = resource_definition
           @resource_fields = resource_fields
+          @card_fields = card_fields
+          # Overrides the show link's turbo-frame target. Defaults to the show
+          # action's own frame (nil → normal navigation). The kanban board sets
+          # "_top" so a card click escapes its column's lazy turbo-frame instead
+          # of loading the show page inside the column.
+          @show_turbo_frame = show_turbo_frame
         end
 
         def view_template
           article(
             class: card_class,
-            data: {controller: "row-click", action: "click->row-click#click"}
+            data: {controller: "row-click", action: "click->row-click#click auxclick->row-click#click"}
           ) do
             render_show_link if can_show?
             render_actions_dropdown
@@ -32,7 +38,12 @@ module Plutonium
 
         private
 
-        def slots = resource_definition.defined_grid_fields
+        # Returns the slot hash used for rendering.
+        # When the kanban board declares `card_fields`, it is passed in
+        # explicitly and takes precedence over the resource definition's
+        # `defined_grid_fields`.  A nil card_fields falls back to the
+        # definition, which is the default for the grid view.
+        def slots = @card_fields || resource_definition.defined_grid_fields
 
         # ---------------------------------------------------------------
         # Layout shells
@@ -116,14 +127,13 @@ module Plutonium
         end
 
         def render_meta_slot
-          fields = Array(slots[:meta])
-          values = fields.map { |f| field_value(f) }.reject(&:blank?)
+          pairs = Array(slots[:meta]).map { |name| [name, field_value(name)] }.reject { |_, value| value.blank? }
 
           div(class: "flex flex-wrap items-center gap-1.5 mt-1") do
-            if values.empty?
+            if pairs.empty?
               render_blank_placeholder
             else
-              values.each { |v| render_meta_badge(v) }
+              pairs.each { |name, value| render_meta_badge(name, value) }
             end
           end
         end
@@ -147,21 +157,38 @@ module Plutonium
             # rendered by the timeago Stimulus controller.
             raw safe(helpers.display_datetime_value(value))
           elsif currency_field?(name)
-            plain helpers.number_to_currency(value, unit: "")
+            plain helpers.number_to_currency(value, unit: currency_unit_for(name))
           else
             plain helpers.display_name_of(value)
           end
         end
 
-        # Renders a meta value as a colored pill, borrowing the Badge
-        # display component's semantic color + humanize logic. Status-like
-        # values (published, pending, failed…) get meaningful colors;
-        # free-form values get a deterministic decorative color.
-        def render_meta_badge(value)
+        # Renders a meta value as a colored pill, borrowing the Badge display
+        # component's semantic color + humanize logic. Non-string types are
+        # formatted by type first so they don't badge their raw value:
+        #   - has_cents columns → currency (matches render_formatted_value)
+        #   - associations → display_name_of (label, not an object inspect)
+        #   - everything else → humanized, with the RAW value driving the
+        #     variant so status-like enums (in_progress, published…) still
+        #     resolve to a semantic color.
+        # The variant hashes the stable formatted label for currency/associations,
+        # so the decorative color no longer churns on an object's memory address.
+        def render_meta_badge(name, value)
           badge = Plutonium::UI::Display::Components::Badge
-          variant = badge.variant_for(value)
+
+          if currency_field?(name)
+            label = helpers.number_to_currency(value, unit: currency_unit_for(name))
+            variant = badge.variant_for(label)
+          elsif association_field?(name)
+            label = helpers.display_name_of(value)
+            variant = badge.variant_for(label)
+          else
+            label = badge.humanize(value)
+            variant = badge.variant_for(value)
+          end
+
           span(class: tokens("pu-badge", "pu-badge-#{variant}")) do
-            plain badge.humanize(value)
+            plain label
           end
         end
 
@@ -170,6 +197,17 @@ module Plutonium
           klass.respond_to?(:has_cents_decimal_attribute?) && klass.has_cents_decimal_attribute?(name.to_sym)
         end
 
+        # Delegates to the shared resolver so cards format currency identically to
+        # the Currency display component — has_cents unit → configured/i18n default,
+        # with `false` meaning no symbol. Cards have no per-display unit (nil).
+        def currency_unit_for(name)
+          Plutonium::UI::Display::Components::Currency.resolve_unit(nil, record, name)
+        end
+
+        def association_field?(name)
+          record.class.reflect_on_association(name.to_sym).present?
+        end
+
         # A declared slot with no value renders a muted em-dash rather than
         # collapsing, so cards in a grid keep an even height instead of
         # ragged rows when some records lack the field.
@@ -201,7 +239,7 @@ module Plutonium
           url = route_options_to_url(show.route_options, record)
           a(
             href: url,
-            data: {row_click_target: "show", turbo_frame: show.turbo_frame(resource_definition)},
+            data: {row_click_target: "show", turbo_frame: @show_turbo_frame || show.turbo_frame(resource_definition)},
             class: "sr-only",
             tabindex: "-1",
             "aria-label": "Open #{header_text}"
@@ -232,7 +270,7 @@ module Plutonium
 
         def row_actions
           @row_actions ||= resource_definition.defined_actions.values.select { |a|
-            a.collection_record_action? && a.permitted_by?(record_policy) && a.condition_met?(view_context, record:)
+            a.collection_record_action? && !a.kanban_drop? && a.permitted_by?(record_policy) && a.condition_met?(view_context, record:)
           }
         end
 

data/lib/plutonium/ui/kanban/card.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Plutonium
+  module UI
+    module Kanban
+      # Thin wrapper around Grid::Card that makes the card draggable.
+      #
+      # Emits a draggable container div carrying:
+      #   data-kanban-record-id — the record's id, consumed by the Stimulus
+      #                           drag controller (Task 11) to identify the card
+      #   data-kanban-column-key — the source column key, used by the move
+      #                            handler (Task 7) to determine which column
+      #                            the card came from
+      #
+      # All actual card rendering (image, header, meta, actions dropdown) is
+      # delegated to Plutonium::UI::Grid::Card which already handles slots,
+      # policy-gated actions, and the row-click controller.
+      class Card < Plutonium::UI::Component::Base
+        attr_reader :record, :column_key, :resource_definition, :resource_fields, :card_fields
+
+        def initialize(record, column_key:, resource_definition:, resource_fields:, card_fields: nil, show_turbo_frame: "_top")
+          @record = record
+          @column_key = column_key
+          @resource_definition = resource_definition
+          @resource_fields = resource_fields
+          # Optional slot-layout override from the board's card_fields declaration.
+          # Threaded through to Grid::Card so it takes precedence over the
+          # resource definition's grid_fields.  nil means use the definition.
+          @card_fields = card_fields
+          # The turbo-frame the card's show link targets — the remote-modal frame
+          # (board show_in :modal) or "_top" (show_in :page). Either escapes the
+          # column's lazy frame. Defaults to "_top".
+          @show_turbo_frame = show_turbo_frame
+        end
+
+        def view_template
+          div(
+            draggable: "true",
+            data: {
+              kanban_record_id: record.id,
+              kanban_column_key: column_key.to_s
+            }
+          ) do
+            render_grid_card
+          end
+        end
+
+        private
+
+        # Extracted so tests can stub render_grid_card without needing a full
+        # view_context (Grid::Card calls policy_for, route_options_to_url, etc.).
+        def render_grid_card
+          render Plutonium::UI::Grid::Card.new(
+            record,
+            resource_definition: resource_definition,
+            resource_fields: resource_fields,
+            card_fields: @card_fields,
+            # Escape the column's lazy turbo-frame: either "_top" (full page) or
+            # the document-wide remote-modal frame, both of which resolve outside
+            # the kanban-col-<key> frame.
+            show_turbo_frame: @show_turbo_frame
+          )
+        end
+      end
+    end
+  end
+end

data/lib/plutonium/ui/kanban/color_dot.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Plutonium
+  module UI
+    module Kanban
+      # Shared color-dot rendering for the board shell placeholder header
+      # (Resource) and the loaded column header (Column), so a column's
+      # `color:` shows consistently in both states.
+      module ColorDot
+        def render_color_dot(color)
+          span(
+            class: "shrink-0 w-2.5 h-2.5 rounded-full",
+            style: "background-color: #{color_css_value(color)}"
+          )
+        end
+
+        # Maps a column color symbol to a CSS value via Tailwind design tokens.
+        # Raw CSS strings (e.g. "#ff0000") are passed through unchanged.
+        def color_css_value(color)
+          case color.to_sym
+          when :red then "var(--color-red-500)"
+          when :orange then "var(--color-orange-500)"
+          when :amber then "var(--color-amber-500)"
+          when :yellow then "var(--color-yellow-500)"
+          when :green then "var(--color-green-500)"
+          when :blue then "var(--color-blue-500)"
+          when :purple then "var(--color-purple-500)"
+          when :pink then "var(--color-pink-500)"
+          when :gray then "var(--pu-text-muted)"
+          else color.to_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/plutonium/ui/kanban/column.rb

@@ -0,0 +1,411 @@
+# frozen_string_literal: true
+
+module Plutonium
+  module UI
+    module Kanban
+      # Renders a single column body: header with wip badge, card list, and a
+      # "+N more" footer when the total exceeds per_column.
+      #
+      # This is the component that Task 6's lazy frame endpoint serves. The
+      # board shell (Resource) wraps each column in a <turbo-frame>; the frame
+      # src hits the column endpoint which renders this component as the body.
+      #
+      # Collapsed variant: when column.collapsed? the component renders a thin
+      # rotated-label strip instead of the full card list. Both the strip and
+      # the expanded body are always emitted in the HTML; CSS (controlled by
+      # the `pu-kanban-column-collapsed` class on the wrapper) shows one and
+      # hides the other. The Stimulus controller's toggleColumn action flips the
+      # class and persists the choice to localStorage.
+      #
+      # Action slot: column.actions are rendered as minimal placeholder buttons
+      # so the DOM seam is in place for Task 8 which wires the actual action
+      # handlers (interactive bulk actions). The buttons carry data-kanban-action
+      # and data-kanban-column attributes for Stimulus targeting.
+      #
+      # Drop policy: the wrapper emits data-kanban-accepts and data-kanban-locked
+      # so the Stimulus drag controller can provide client-side drop hints without
+      # re-implementing server-side logic. The server remains the authority.
+      class Column < Plutonium::UI::Component::Base
+        include ColorDot
+        include Phlex::Rails::Helpers::LinkTo
+
+        attr_reader :column, :cards, :total, :per_column, :resource_definition, :resource_fields
+
+        # column_action_data: array of {action: Plutonium::Kanban::Action, ids: [Integer, ...]}
+        # Resolved by the controller (KanbanActions#render_kanban_column_html) and
+        # threaded here so the component can render real bulk-action links without
+        # needing to re-query the DB.  Defaults to [] when the component is
+        # constructed outside of a controller context (e.g., tests or the board
+        # shell which renders column frames without card data).
+        #
+        # column_add_url: URL for the "+ Add" quick-add button (or nil).
+        # Set by the controller when column.add? is true and the policy permits
+        # create. Carries kanban_column=<key> so the new form pre-fills the
+        # grouping attribute via apply_kanban_column_defaults!.
+        #
+        # card_fields: optional slot-layout hash from the board's card_fields
+        # declaration (e.g. { header: :title, meta: [:status] }).  Threaded
+        # through to each Kanban::Card (and ultimately Grid::Card) so it
+        # overrides the resource definition's grid_fields for every card in the
+        # column.  nil means "use the definition's grid_fields" (default).
+        # card_show_frame: the turbo-frame each card's show link targets — the
+        # remote-modal frame (board show_in :modal) or "_top" (show_in :page).
+        # Resolved by the controller and threaded through to Kanban::Card.
+        # Defaults to "_top" so a card always escapes the column's lazy frame when
+        # the component is built outside a controller (tests, board shell).
+        # collapsed: the EFFECTIVE collapse state for this render (the user's
+        # cookie-persisted choice resolved against the column default by the
+        # controller). nil → fall back to the column's declared default. The
+        # component still emits the DEFAULT separately (data-kanban-default-
+        # collapsed) so the controller can store only deltas from it.
+        # drop_form_url_template: the kanban_move_form member URL with an __ID__
+        # placeholder for the dragged card's record id (mirrors the board's
+        # move-url template). Set by the controller ONLY for columns that declare
+        # an enter_interaction:; nil for plain columns. When present, the wrapper
+        # advertises data-kanban-drop-interaction + data-kanban-drop-form-url-
+        # template so Task 6's Stimulus controller opens the interaction modal on
+        # drop instead of committing the move immediately.
+        def initialize(column:, cards:, total:, per_column:, resource_definition:, resource_fields:, column_action_data: [], column_add_url: nil, board_url: nil, card_fields: nil, card_show_frame: "_top", collapsed: nil, drop_form_url_template: nil, drop_immediate: false, drop_confirm: nil)
+          @column = column
+          @cards = cards
+          @total = total
+          @per_column = per_column
+          @resource_definition = resource_definition
+          @resource_fields = resource_fields
+          @column_action_data = column_action_data
+          @column_add_url = column_add_url
+          @board_url = board_url
+          @card_fields = card_fields
+          @card_show_frame = card_show_frame
+          @collapsed = collapsed
+          @drop_form_url_template = drop_form_url_template
+          @drop_immediate = drop_immediate
+          @drop_confirm = drop_confirm
+        end
+
+        # Effective collapse state: the caller's resolved value, or the column
+        # default when none was passed (tests / board shell / non-cookie paths).
+        def effective_collapsed?
+          @collapsed.nil? ? column.collapsed? : @collapsed
+        end
+
+        def view_template
+          # Wrapper carries the drop-policy data attributes and the initial
+          # collapsed CSS class. The Stimulus controller reads data-kanban-col
+          # to find wrappers unambiguously (distinct from toggle button attrs).
+          div(
+            class: tokens(
+              "pu-kanban-column-wrapper",
+              effective_collapsed? && "pu-kanban-column-collapsed"
+            ),
+            data: wrapper_data
+          ) do
+            render_collapsed_strip
+            render_expanded
+          end
+        end
+
+        private
+
+        # Data attributes for the [data-kanban-col] wrapper. Drop-policy hints
+        # (accepts/locked) and the collapse default are always present; the
+        # drop-interaction attributes are added only when the column declares an
+        # enter_interaction: (advertised via the controller-computed template).
+        def wrapper_data
+          data = {
+            kanban_col: column.key.to_s,
+            # The DEFAULT (not the effective state) so the controller can store
+            # only a delta from it in the cookie.
+            kanban_default_collapsed: column.collapsed?.to_s,
+            kanban_accepts: accepts_value,
+            kanban_locked: column.locked?.to_s
+          }
+
+          if column.enter_interaction?
+            data[:kanban_drop_interaction] = "true"
+            data[:kanban_drop_form_url_template] = @drop_form_url_template
+            # An input-less interaction commits directly on drop (no form modal);
+            # the client reads this to skip opening an empty modal. The optional
+            # confirm message (auto "<label>?" for immediate actions) gates it.
+            data[:kanban_drop_immediate] = "true" if @drop_immediate
+            data[:kanban_drop_confirm] = @drop_confirm if @drop_confirm.present?
+          end
+
+          data
+        end
+
+        # ---------------------------------------------------------------
+        # Collapsed strip
+        # ---------------------------------------------------------------
+
+        def render_collapsed_strip
+          # CSS hides this strip when the wrapper lacks pu-kanban-column-collapsed.
+          # Always emitted so the JS toggle can switch between strip and body
+          # without a server round-trip.
+          div(
+            class: "pu-kanban-strip w-10 flex flex-col items-center justify-between " \
+                   "py-3 gap-2 bg-[var(--pu-surface)] border border-[var(--pu-border)] " \
+                   "rounded-[var(--pu-radius-md)] select-none",
+            data: {kanban_role: "strip"}
+          ) do
+            # The color dot is the outcome signal for terminal columns (:done
+            # green, :lost red) — keep it visible when collapsed too.
+            render_color_dot(column.color) if column.color
+            span(
+              class: "text-xs font-semibold text-[var(--pu-text-muted)] " \
+                     "[writing-mode:vertical-lr] rotate-180"
+            ) { plain column.label }
+            span(class: "pu-badge pu-badge-neutral text-xs font-mono") { plain cards.size.to_s }
+            # Expand toggle button — the primary interactive seam for
+            # collapsing/expanding. data-kanban-column-key is on this button so
+            # the integration test can assert the contract without JS execution.
+            button(
+              class: "p-0.5 rounded text-[var(--pu-text-muted)] " \
+                     "hover:text-[var(--pu-text)] hover:bg-[var(--pu-surface-alt)]",
+              title: "Expand #{column.label}",
+              type: "button",
+              data: {
+                action: "click->kanban#toggleColumn",
+                kanban_column_key: column.key.to_s
+              }
+            ) { plain "▶" }
+            # No column actions here: a collapsed column is a thin strip, so its
+            # bulk actions (and "+ Add") stay hidden until it's expanded. They
+            # live only in the expanded header (render_header).
+          end
+        end
+
+        # ---------------------------------------------------------------
+        # Expanded column
+        # ---------------------------------------------------------------
+
+        def render_expanded
+          # CSS hides this body when the wrapper has pu-kanban-column-collapsed.
+          div(
+            class: "pu-kanban-body pu-kanban-column w-72 shrink-0 flex flex-col " \
+                   "bg-[var(--pu-surface-alt)] border border-[var(--pu-border)] " \
+                   "rounded-[var(--pu-radius-md)] overflow-hidden",
+            data: {kanban_role: "body"}
+          ) do
+            render_header
+            render_card_list
+            render_more_footer if more_count > 0
+          end
+        end
+
+        def render_header
+          div(class: "px-3 py-2 flex items-center justify-between gap-2 border-b border-[var(--pu-border)] bg-[var(--pu-surface)]") do
+            div(class: "flex items-center gap-2 min-w-0 flex-1") do
+              render_color_dot(column.color) if column.color
+              span(class: "font-semibold text-sm text-[var(--pu-text)] truncate") { plain column.label }
+              # Always show a card count (matching the collapsed strip); when a
+              # WIP limit is set it becomes the "count/limit" badge instead.
+              if column.wip
+                render_wip_badge
+              else
+                render_count_badge
+              end
+            end
+            render_column_actions if @column_add_url || column.actions.any?
+            # Collapse toggle — always present in the expanded header so the
+            # user can collapse a column even when no other actions are visible.
+            # Kept outside render_column_actions so the action-slot tests are
+            # unaffected (they check the flex-gap container which is conditional).
+            button(
+              class: "shrink-0 p-0.5 rounded text-[var(--pu-text-muted)] " \
+                     "hover:text-[var(--pu-text)] hover:bg-[var(--pu-surface-alt)]",
+              title: "Collapse #{column.label}",
+              type: "button",
+              data: {
+                action: "click->kanban#toggleColumn",
+                kanban_column_key: column.key.to_s
+              }
+            ) { plain "◀" }
+          end
+        end
+
+        # Plain card-count badge for columns without a WIP limit — mirrors the
+        # count shown on the collapsed strip so the number is visible either way.
+        def render_count_badge
+          span(class: "pu-badge pu-badge-neutral text-xs font-mono") { plain cards.size.to_s }
+        end
+
+        def render_wip_badge
+          over = wip_over_limit?
+          span(
+            class: tokens(
+              "pu-badge text-xs font-mono",
+              over ? "pu-badge-danger" : "pu-badge-neutral"
+            ),
+            title: over ? "WIP limit exceeded" : "WIP limit: #{column.wip}"
+          ) do
+            plain "#{cards.size}/#{column.wip}"
+          end
+        end
+
+        # ---------------------------------------------------------------
+        # Card list
+        # ---------------------------------------------------------------
+
+        def render_card_list
+          div(
+            class: "flex flex-col gap-2 p-2 min-h-[3rem] flex-1",
+            data: {
+              kanban_target: "column",
+              kanban_column_key_value: column.key.to_s
+            }
+          ) do
+            render_cards
+          end
+        end
+
+        # Extracted so tests can stub render_cards without needing a real
+        # view_context (Grid::Card requires policy_for etc.).
+        def render_cards
+          cards.each do |record|
+            render Plutonium::UI::Kanban::Card.new(
+              record,
+              column_key: column.key,
+              resource_definition: resource_definition,
+              resource_fields: resource_fields,
+              card_fields: @card_fields,
+              show_turbo_frame: @card_show_frame
+            )
+          end
+        end
+
+        # ---------------------------------------------------------------
+        # "+N more" footer
+        # ---------------------------------------------------------------
+
+        def render_more_footer
+          div(class: "px-3 py-2 border-t border-[var(--pu-border)] bg-[var(--pu-surface)]") do
+            span(class: "text-xs text-[var(--pu-text-muted)]") do
+              plain "+#{more_count} more"
+            end
+          end
+        end
+
+        # ---------------------------------------------------------------
+        # Column action slot
+        # ---------------------------------------------------------------
+
+        # Renders the "+ Add" quick-add button that opens the resource's new form
+        # in the remote modal frame, pre-seeded for this column.
+        def render_add_button
+          link_to(
+            @column_add_url,
+            class: "pu-btn pu-btn-ghost pu-btn-xs text-[var(--pu-text-muted)]",
+            title: "Add to #{column.label}",
+            data: {turbo_frame: Plutonium::REMOTE_MODAL_FRAME}
+          ) do
+            plain "+ Add"
+          end
+        end
+
+        # Renders bulk-action links for each column action, and the "+ Add"
+        # quick-add button when column_add_url is present.
+        #
+        # Each link targets /resources/bulk_actions/:key?ids[]=… — the same path
+        # for the GET form and the POST commit. The render mirrors ActionButton so
+        # the action's shape is honoured (see #column_action_link_data):
+        #   • an interaction with NO user inputs is `immediate` → POST + confirm,
+        #     executed directly instead of opening an empty form modal;
+        #   • one with inputs opens the interaction form in the remote modal.
+        #
+        # The action is only rendered when it's registered in defined_actions
+        # (auto-registered by Definition::IndexViews.kanban) and permitted by the
+        # policy. The bulk endpoint re-authorizes each record, so this is a
+        # display-only gate, not the security boundary.
+        def render_column_actions
+          div(class: "flex items-center gap-1 shrink-0") do
+            render_add_button if @column_add_url
+            @column_action_data.each do |entry|
+              col_action = entry[:action]
+              ids = entry[:ids]
+
+              registered = current_definition.defined_actions[col_action.key]
+              next unless registered&.permitted_by?(current_policy)
+
+              # Skip when the resolved id set is empty: resource_url_for with
+              # ids: [] would resolve to the RESOURCE action route
+              # (/resource_actions/:key) rather than the bulk route, misfiring
+              # if clicked. An empty column simply renders no action link.
+              next if ids.empty?
+
+              # return_to the board so the action redirects back to it (not the
+              # table index) AND the board refreshes: the board-bound redirect is
+              # tagged with kanban_reload (KanbanActions#kanban_reload_url), so the
+              # column re-fetches and the mutated cards (e.g. archived) update.
+              url = resource_url_for(resource_class, interaction: col_action.key, ids: ids, return_to: @board_url)
+              label = col_action.label || col_action.key.to_s.humanize
+
+              link_to(
+                url,
+                class: "pu-btn pu-btn-ghost pu-btn-xs text-[var(--pu-text-muted)]",
+                title: label,
+                data: column_action_link_data(col_action, registered)
+              ) do
+                render col_action.icon.new(class: "h-4 w-4") if col_action.icon
+                plain label
+              end
+            end
+          end
+        end
+
+        # Data attributes for a column-action link, honouring the interaction's
+        # shape. `immediate` actions (no inputs) POST straight to the commit route
+        # with a confirmation, executed directly; the rest open the form in the
+        # remote modal. The confirmation prefers the DSL-supplied one, falling
+        # back to the action's own default ("<label>?" for immediate actions).
+        def column_action_link_data(col_action, registered)
+          data = {
+            kanban_action: col_action.key.to_s,
+            kanban_column: column.key.to_s
+          }
+
+          if registered.immediate
+            data[:turbo_method] = :post
+            confirmation = col_action.confirmation || registered.confirmation
+            data[:turbo_confirm] = confirmation if confirmation.present?
+          else
+            data[:turbo_frame] = Plutonium::REMOTE_MODAL_FRAME
+            data[:turbo_confirm] = col_action.confirmation if col_action.confirmation
+          end
+
+          data
+        end
+
+        # ---------------------------------------------------------------
+        # Pure helpers
+        # ---------------------------------------------------------------
+
+        def wip_over_limit?
+          column.wip && cards.size > column.wip
+        end
+
+        def more_count
+          [total - cards.size, 0].max
+        end
+
+        # Serialises the column's accepts policy for the data-kanban-accepts
+        # attribute consumed by the Stimulus drag controller for drop hints.
+        # The server remains the authority; this is display only.
+        #
+        # true  → "all"    (any source is accepted)
+        # false → "none"   (no source is accepted)
+        # Array → comma-joined list of accepted source column keys
+        # Proc  → "all"    (per-card predicate; treated as permissive at the
+        #                    column level — server evaluates per record)
+        def accepts_value
+          case column.accepts
+          when true then "all"
+          when false then "none"
+          when Array then column.accepts.join(",")
+          else "all"
+          end
+        end
+      end
+    end
+  end
+end