plutonium 0.62.2 → 0.63.0

data/lib/plutonium/ui/page/show.rb

@@ -15,7 +15,7 @@ module Plutonium
         end
 
         def page_actions
-          super || current_definition.defined_actions.values.select { |a| a.record_action? && !a.kanban_drop? && a.permitted_by?(current_policy) && a.condition_met?(view_context, record: resource_record!) }
+          super || current_definition.defined_actions.values.select { |a| a.record_action? && !a.hidden? && a.permitted_by?(current_policy) && a.condition_met?(view_context, record: resource_record!) }
         end
 
         def render_default_content
@@ -25,28 +25,45 @@ module Plutonium
           # modal: a slideover/centered dialog has no room for a side rail.
           return render_modal_details if in_modal?
 
-          if aside_present?
-            div(class: "grid grid-cols-1 lg:grid-cols-[minmax(0,1fr)_240px] gap-6") do
-              div { render partial("resource_details") }
-              aside(class: "hidden lg:block") { render_aside }
+          # Width comes from configuration (`page_width` / `display_width` on
+          # the definition). A modal is excluded above — the dialog sizes
+          # itself — and `:full` resolves to no classes, leaving the markup
+          # exactly as it was before widths were configurable.
+          constrain_width do
+            if aside_present?
+              div(class: "grid grid-cols-1 lg:grid-cols-[minmax(0,1fr)_240px] gap-6") do
+                div { render partial("resource_details") }
+                aside(class: "hidden lg:block") { render_aside }
+              end
+            else
+              render partial("resource_details")
             end
-          else
-            render partial("resource_details")
           end
         end
 
+        # Wraps the content in the configured width, or yields bare when the
+        # resolved width is `:full` — so an unconstrained page gains no
+        # pointless wrapper div.
+        def constrain_width(&block)
+          classes = current_definition.display_width_classes
+          return yield if classes.nil?
+
+          div(class: classes, &block)
+        end
+
         # The show page is ALWAYS a centered dialog when shown in a modal —
         # deliberately not the definition's modal_mode (which styles :new/:edit
         # as a slideover by default). A centered dialog reads as a focused
         # "detail card" and leaves a launching board/table visible around it.
-        # `open_full_url` is the current show URL (request.path is the show
-        # route here), letting the user pop the record out to its full page.
+        # `open_full_url` lets the user pop the record out to its full page —
+        # notably dropping `kanban_modal`, so a card expanded out of a board
+        # regains the metadata rail that the modal hides.
         def render_modal_details
           render Plutonium::UI::Modal::Centered.new(
             title: page_title,
             description: page_description,
             size: :lg,
-            open_full_url: request.path
+            open_full_url: open_full_page_url
           ) do
             # The modal body owns no padding — content provides its own (the
             # form uses this same padded, scrollable region). Without it the

data/lib/plutonium/ui/page/wizard.rb

@@ -26,7 +26,7 @@ module Plutonium
 
         def view_template(&)
           DynaFrameContent() do
-            article(class: "pu-wizard mx-auto max-w-3xl", data: {controller: "wizard"}) do
+            article(class: tokens("pu-wizard", wizard_width_classes), data: {controller: "wizard"}) do
               render_header
               render_stepper
               render_body
@@ -43,6 +43,14 @@ module Plutonium
 
         # Centered wizard header: the title and the wizard-level description
         # (`presents description:`). The per-step heading lives on the step card.
+        # Wizard step width. The wizard class resolves it: its own `width`,
+        # else `config.wizards.width`. Deliberately does NOT fall through to
+        # `config.default_page_width` — wizard widths are configured on their
+        # own axis, so moving resource pages leaves wizards where they are.
+        def wizard_width_classes
+          Plutonium::UI::PageWidth.classes_for(@runner.wizard.class.width)
+        end
+
         def render_header
           div(class: "pu-wizard-header mb-7 text-center") do
             h1(class: "text-2xl font-bold tracking-tight text-[var(--pu-text)]") do
@@ -128,6 +136,7 @@ module Plutonium
               render_step_header(step)
               render Plutonium::UI::Form::Wizard.new(
                 step:,
+                wizard: @runner.wizard,
                 # Decorate so attachment fields read as resolved attachments (the
                 # Uppy preview rehydrates on Back/resume); other fields pass through.
                 data: Plutonium::Wizard::AttachmentData.wrap(@runner.wizard.data[step.key], step),

data/lib/plutonium/ui/page/wizard_chooser.rb

@@ -5,10 +5,10 @@ module Plutonium
     module Page
       # The "resume or start new" chooser (§4.5), shown at the bare launch URL when
       # a tokened wizard opts in with `on_relaunch :prompt` and the user already has
-      # pending (in-progress) runs. Lists each pending run with a Resume link and
-      # offers a Start-new button. Keyed/one-time/anchored wizards never reach here
-      # (they auto-resume their single keyed run); only tokened wizards can have
-      # several concurrent runs to choose between.
+      # pending (in-progress) runs. Lists each pending run with a Resume link and a
+      # Cancel button, and offers a Start-new button. Keyed/one-time/anchored
+      # wizards never reach here (they auto-resume their single keyed run); only
+      # tokened wizards can have several concurrent runs to choose between.
       class WizardChooser < Plutonium::UI::Page::Base
         # @param wizard_class  [Class] the wizard being launched.
         # @param entries       [Array<Plutonium::Wizard::Resume::Entry>] pending runs.
@@ -57,9 +57,9 @@ module Plutonium
           end
         end
 
-        # One pending run: its current step + when it was last touched, and a Resume
-        # link. A run whose mount can't be resolved (no `resume_url`) is shown as a
-        # disabled row rather than a dead link.
+        # One pending run: its current step + when it was last touched, a Resume link
+        # and a Cancel button. A run whose mount can't be resolved (no `resume_url`)
+        # is shown as a disabled row rather than a dead link.
         def render_entry(entry)
           li(class: "flex items-center justify-between gap-4 px-5 py-4", data: {wizard_chooser_entry: entry.current_step}) do
             div(class: "min-w-0") do
@@ -68,14 +68,39 @@ module Plutonium
               end
               p(class: "mt-0.5 text-xs text-[var(--pu-text-muted)]") { "Updated #{updated_ago(entry)} ago" }
             end
-            if entry.resume_url.present?
-              a(href: entry.resume_url, class: "pu-btn pu-btn-sm pu-btn-outline shrink-0", data: {wizard_chooser_resume: true}) { "Resume" }
-            else
-              span(class: "pu-btn pu-btn-sm pu-btn-outline shrink-0 opacity-50 cursor-not-allowed") { "Resume" }
+            div(class: "flex items-center gap-2 shrink-0") do
+              if entry.resume_url.present?
+                a(href: entry.resume_url, class: "pu-btn pu-btn-sm pu-btn-outline", data: {wizard_chooser_resume: true}) { "Resume" }
+              else
+                span(class: "pu-btn pu-btn-sm pu-btn-outline opacity-50 cursor-not-allowed") { "Resume" }
+              end
+
+              render_cancel_form(entry) if entry.cancel_url.present?
             end
           end
         end
 
+        # Abandoning a run is destructive and irreversible — cancelling runs every
+        # step's `on_rollback`, destroys the records it persisted, then deletes the
+        # row. So it goes through a DELETE form (never a link) behind a
+        # `data-turbo-confirm` prompt. Turbo reads `turbo_confirm`; plain
+        # `data-confirm` is Rails UJS and would silently never fire here.
+        def render_cancel_form(entry)
+          form(action: entry.cancel_url, method: "post", class: "inline-block") do
+            input(type: "hidden", name: "_method", value: "delete")
+            input(type: "hidden", name: "authenticity_token", value: helpers.form_authenticity_token)
+            button(
+              type: "submit",
+              class: "pu-btn pu-btn-sm pu-btn-soft-danger",
+              aria_label: "Cancel this #{@wizard_class.label} draft",
+              data: {
+                wizard_chooser_cancel: true,
+                turbo_confirm: "Discard this in-progress #{@wizard_class.label}? This can't be undone."
+              }
+            ) { "Cancel" }
+          end
+        end
+
         def render_start_new
           div(class: "border-t border-[var(--pu-border)] bg-[var(--pu-surface-alt)] px-5 py-4") do
             a(href: @start_new_url, class: "pu-btn pu-btn-md pu-btn-primary w-full justify-center", data: {wizard_chooser_start_new: true}) do

data/lib/plutonium/ui/page_width.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Plutonium
+  module UI
+    # The width vocabulary for detail-style pages — the show page, resource
+    # forms and wizard steps.
+    #
+    # These pages are read and filled top-to-bottom in a single column. Inputs
+    # and values stretch to their container, so at full content width on a wide
+    # screen you get ~1200px-long lines and text boxes: past a comfortable
+    # measure, and a long eye-travel between a label and the value beside it.
+    # Index and table pages are deliberately NOT covered — a table wants every
+    # pixel it can get.
+    #
+    # The tokens deliberately mirror {Plutonium::UI::Modal::Base::VALID_SIZES}
+    # so the framework has one width language rather than two.
+    module PageWidth
+      # Token => the max-width utility it resolves to. `:full` is the opt-out:
+      # no constraint at all, the historical behaviour.
+      SIZES = {
+        sm: "max-w-2xl",
+        md: "max-w-4xl",
+        lg: "max-w-6xl",
+        xl: "max-w-7xl",
+        full: nil
+      }.freeze
+
+      VALID_SIZES = SIZES.keys.freeze
+
+      # The classes for a token: a max-width plus the centring that makes it
+      # read as a column rather than a left-hugging block. `:full` contributes
+      # nothing, so an unconstrained page keeps exactly the markup it had
+      # before this vocabulary existed.
+      #
+      # @param size [Symbol]
+      # @return [String, nil]
+      def self.classes_for(size)
+        max_width = SIZES.fetch(size) { raise_unknown(size) }
+        return nil if max_width.nil?
+
+        "#{max_width} mx-auto"
+      end
+
+      # Raises on an unknown token rather than silently falling back, matching
+      # `modal` and `show_in`. A typo'd width is a bug, not a default.
+      def self.validate!(size)
+        return size if VALID_SIZES.include?(size)
+        raise_unknown(size)
+      end
+
+      def self.raise_unknown(size)
+        raise ArgumentError,
+          "page width must be one of #{VALID_SIZES.inspect}, got #{size.inspect}"
+      end
+      private_class_method :raise_unknown
+    end
+  end
+end

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

@@ -12,7 +12,40 @@ module Plutonium
         # button). Rows without such a target become a no-op — no
         # special-casing needed in this layer.
         def table_body_row_attributes(wrapped_object)
-          super.merge(data: {controller: "row-click", action: "click->row-click#click auxclick->row-click#click"})
+          attributes = super.merge(data: {controller: "row-click", action: "click->row-click#click auxclick->row-click#click"})
+          return attributes unless positioned?
+
+          # The row — never the grip — is the single source of truth for which
+          # record a drag is about. See positioned_controller.js.
+          row_data = attributes[:data].merge(positioned_row_id: wrapped_object.identifier)
+
+          # Present only for a scoped resource, where a drop across groups is
+          # meaningless and the drag must refuse it (see Positionable).
+          group = @options[:positioned_group_resolver]&.call(wrapped_object.unwrapped)
+          row_data = row_data.merge(positioned_group: group) unless group.nil?
+
+          attributes.merge(data: row_data)
+        end
+
+        # Scope the drag controller to the div that wraps <table>: the tightest
+        # element that contains every row, and nothing else the drag cares about.
+        def table_wrapper_attributes
+          return super unless positioned?
+
+          super.merge(
+            data: {
+              controller: "positioned",
+              positioned_url_template_value: @options[:positioned_url_template]
+            }
+          )
+        end
+
+        # Reorderable AND currently orderable. Table::Resource passes the
+        # template only when the collection is in ascending position order — a
+        # drop under any other sort is rejected by the server, so the client must
+        # not offer it (the grip still renders, disabled, to say so).
+        def positioned?
+          @options[:positioned_url_template].present?
         end
 
         # Use custom SelectionColumn with Stimulus data attributes

data/lib/plutonium/ui/table/components/attachment.rb

@@ -27,7 +27,7 @@ module Plutonium
                 attachment_preview_thumbnail_url_value: attachment_thumbnail_url(attachment),
                 attachment_preview_target: "thumbnail"
               },
-              title: attachment.filename
+              title: attachment.filename.to_s
             ) do
               a(
                 href: attachment.url,

data/lib/plutonium/ui/table/components/bulk_actions_toolbar.rb

@@ -59,17 +59,19 @@ module Plutonium
           end
 
           def render_action_button(action)
-            url = route_options_to_url(action.route_options, resource_class)
+            url = with_return_to(route_options_to_url(action.route_options, resource_class))
 
             link_to(
               url,
-              class: button_classes(action),
-              data: {
-                bulk_actions_target: "actionButton",
-                bulk_action_name: action.name,
-                bulk_action_url: url,
-                turbo_frame: action.turbo_frame(current_definition)
-              }
+              action.link_attributes({
+                class: button_classes(action),
+                data: {
+                  bulk_actions_target: "actionButton",
+                  bulk_action_name: action.name,
+                  bulk_action_url: url,
+                  turbo_frame: action.turbo_frame(current_definition)
+                }
+              })
             ) do
               if action.icon
                 render action.icon.new(class: "h-4 w-4")
@@ -78,6 +80,28 @@ module Plutonium
             end
           end
 
+          # Carries the index the user is on into the action, the same way
+          # ActionButton does for row and page actions.
+          #
+          # Without it a bulk action has nowhere to send the user back to. That
+          # is invisible for an action that redirects to the record it changed,
+          # and very visible for one that DISPATCHES: async interactions honour
+          # return_to (see Dispatchable#dispatch_redirect_target), so a user who
+          # archived the rows they had selected was landed on a progress page
+          # with their list two clicks behind them.
+          #
+          # current_page_url, not request.original_url, for the reason
+          # ActionButton#default_return_to gives: a toolbar re-rendered by a
+          # stream-producing POST must return the user to the page they are on,
+          # never to that POST-only endpoint.
+          def with_return_to(url)
+            uri = URI.parse(url)
+            params = Rack::Utils.parse_nested_query(uri.query)
+            params["return_to"] = current_page_url
+            uri.query = params.to_query
+            uri.to_s
+          end
+
           def button_classes(action)
             color_key = (action.color || action.category)&.to_sym || :primary
             color_class = COLOR_CLASSES[color_key] || COLOR_CLASSES[:primary]

data/lib/plutonium/ui/table/components/drag_handle.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module Plutonium
+  module UI
+    module Table
+      module Components
+        # The drag affordance for a reorderable row.
+        #
+        # ## Why it lives inside the first cell rather than in a column of its own
+        #
+        # A dedicated grip column would cost horizontal space on EVERY row of
+        # every reorderable table, forever, for a gesture used occasionally. So
+        # the grip is pulled left into the first cell's padding with a negative
+        # margin exactly equal to its own width: it occupies the padding the cell
+        # already had, and the cell's content does not shift by a pixel — with or
+        # without the grip, hovered or not.
+        #
+        # (The padding, not a negative offset outside the cell: the body cell is
+        # `overflow-hidden`, which clips at the PADDING box. Anything positioned
+        # beyond it would simply be invisible.)
+        #
+        # ## Why the grip is draggable and the <tr> is not
+        #
+        # See positioned_controller.js — `draggable="true"` kills text selection
+        # inside the element, and a draggable row fights row_click_controller.
+        # Both would be silent regressions on an ordinary data table.
+        #
+        # ## The disabled state IS the way out of the disabled state
+        #
+        # Dropping between two rows only means something when the visual order is
+        # the stored order, so the server rejects a drop made under any other sort
+        # (including a DESCENDING position sort). Rather than hiding the
+        # affordance — which would leave the user with no hint that the table is
+        # reorderable at all, and no way to make it so — it renders as a link that
+        # applies the ascending position sort. That is precisely why `position_on`
+        # registers `sort <attribute>`.
+        #
+        # ## Why one component serves both the table and the card grid
+        #
+        # The behaviour — draggable button, keyboard hint, disabled-is-the-way-out
+        # link — is identical on both surfaces; only WHERE the grip sits differs.
+        # A table row has padding to hide it in, a card does not, so the placement
+        # is the one thing `variant:` switches (see Table::Theme). Two components
+        # would mean two chances for the drag contract to drift.
+        class DragHandle < Phlexi::Table::HTML
+          # Placement only — never behaviour. :row tucks the grip into a table
+          # cell's existing left padding; :card floats it over the card's
+          # top-left corner, since a card has no spare gutter to hide it in.
+          VARIANTS = {
+            row: {grip: :drag_handle, disabled: :drag_handle_disabled},
+            card: {grip: :drag_handle_card, disabled: :drag_handle_card_disabled}
+          }.freeze
+
+          # @param sort_url [String, nil] nil when dragging is live; otherwise the
+          #   URL that puts the collection back into ascending position order.
+          # @param variant [Symbol] :row (table cell) or :card (grid card)
+          def initialize(sort_url: nil, variant: :row)
+            @sort_url = sort_url
+            @variant = VARIANTS.fetch(variant)
+          end
+
+          def view_template
+            @sort_url ? render_disabled : render_grip
+          end
+
+          private
+
+          def render_grip
+            button(
+              type: "button",
+              draggable: "true",
+              class: themed(@variant[:grip]),
+              title: "Drag to reorder",
+              aria: {label: "Drag to reorder. Use the up and down arrow keys to move this row."},
+              data: {positioned_grip: ""}
+            ) { icon }
+          end
+
+          def render_disabled
+            a(
+              href: @sort_url,
+              class: themed(@variant[:disabled]),
+              title: "Sort by position to reorder"
+            ) { icon }
+          end
+
+          def icon
+            render Phlex::TablerIcons::GripVertical.new(class: "w-4 h-4")
+          end
+
+          # A first-column cell with a grip in front of it.
+          #
+          # The table renders whatever the column's own block returned; this
+          # wraps that component rather than replacing it, so a formatter, a
+          # custom block or an inferred display component all keep rendering
+          # exactly as they did. Flex rather than inline flow because that inner
+          # component may be block or inline depending on the field type, and the
+          # grip must sit beside it either way.
+          #
+          # Nested inside DragHandle so referencing it loads this file — a
+          # sibling top-level class in drag_handle.rb would be invisible to
+          # Zeitwerk until something happened to touch DragHandle first.
+          class Cell < Phlexi::Table::HTML
+            def initialize(cell, sort_url: nil)
+              @cell = cell
+              @sort_url = sort_url
+            end
+
+            def view_template
+              div(class: themed(:drag_handle_cell)) do
+                render DragHandle.new(sort_url: @sort_url)
+                div(class: "min-w-0") { render @cell }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/plutonium/ui/table/components/filter_form.rb

@@ -142,10 +142,7 @@ module Plutonium
             tag = input_options[:as] || field_options[:as]
             tag_attributes = input_options.except(:wrapper, :as)
 
-            tag_block = input_definition[:block] || ->(f) {
-              tag ||= f.inferred_field_component
-              f.send(:"#{tag}_tag", **tag_attributes, class: "w-full")
-            }
+            tag_block = input_definition[:block] || ->(f) { f.component_for(tag, **tag_attributes, class: "w-full") }
 
             field_options = field_options.except(:as)
 

data/lib/plutonium/ui/table/components/filter_pills.rb

@@ -74,7 +74,7 @@ module Plutonium
                 keep["q"] = cleaned
               end
             end
-            "#{request.path}?#{keep.to_query}"
+            "#{@query.request_path}?#{keep.to_query}"
           end
 
           def render_result_count

data/lib/plutonium/ui/table/components/row_actions_dropdown.rb

@@ -34,7 +34,7 @@ module Plutonium
 
           def render_dropdown_menu
             div(
-              class: "hidden absolute right-0 z-50 mt-1 w-40 origin-top-right bg-[var(--pu-surface)] border border-[var(--pu-border)] rounded-[var(--pu-radius-md)] overflow-hidden",
+              class: "hidden absolute right-0 z-50 mt-1 w-max min-w-40 max-w-[min(20rem,90vw)] origin-top-right bg-[var(--pu-surface)] border border-[var(--pu-border)] rounded-[var(--pu-radius-md)] overflow-hidden",
               style: "box-shadow: var(--pu-shadow-lg)",
               data: {resource_drop_down_target: "menu"}
             ) do

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

@@ -4,6 +4,8 @@ module Plutonium
   module UI
     module Table
       class Resource < Plutonium::UI::Component::Base
+        include Plutonium::UI::Component::Positionable
+
         attr_reader :collection, :resource_fields, :resource_definition
 
         def initialize(collection, resource_fields:, resource_definition:)
@@ -73,7 +75,7 @@ module Plutonium
         end
 
         def current_search_url
-          request.path
+          current_query_object.request_path
         end
 
         def render_bulk_actions_toolbar
@@ -92,7 +94,9 @@ module Plutonium
         end
 
         def render_table
-          render Plutonium::UI::Table::Base.new(collection) do |table|
+          table_options = position_drag_enabled? ? {positioned_url_template: position_url_template, positioned_group_resolver: position_group_resolver} : {}
+
+          render Plutonium::UI::Table::Base.new(collection, **table_options) do |table|
             # Selection column only renders when bulk actions exist —
             # the server already knows, so no JS toggle is needed.
             # Use :_selection as column key to avoid conflicts with field columns;
@@ -103,6 +107,11 @@ module Plutonium
                 policy_resolver: ->(record) { policy_for(record:) }
             end
 
+            # The grip rides in the FIRST column that actually renders — tracked
+            # rather than indexed off @resource_fields, because a `condition:`
+            # can skip the nominal first column and the grip must not go with it.
+            grip_pending = !position_config.nil?
+
             @resource_fields.each do |name|
               field_options = resource_definition.defined_fields[name] ? resource_definition.defined_fields[name][:options].dup : {}
 
@@ -125,6 +134,13 @@ module Plutonium
               display_tag_attributes = display_options.except(:wrapper, :as, :condition, *field_level_keys)
               column_tag_attributes = column_options.except(:wrapper, :as, :align, :condition, *field_level_keys)
               tag_attributes = display_tag_attributes.merge(column_tag_attributes)
+
+              # A `formatter:` produces the cell string itself, so render it
+              # through the formatted-value component regardless of the column'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 = if column_definition[:block]
                 # User-provided blocks receive the raw record for convenience
                 user_block = column_definition[:block]
@@ -132,11 +148,18 @@ module Plutonium
               else
                 ->(wrapped_object, key) {
                   f = wrapped_object.field(key)
+                  # Infer ONCE per column (this block runs per row), so every row
+                  # renders through the same tag even where values differ in type.
                   tag ||= f.inferred_field_component
-                  f.send(:"#{tag}_tag", **tag_attributes)
+                  f.component_for(tag, **tag_attributes)
                 }
               end
 
+              if grip_pending
+                grip_pending = false
+                tag_block = wrap_with_drag_handle(tag_block)
+              end
+
               # For table columns, only extract column-level options (label and align)
               # Field-level options like description and placeholder don't make sense in table cells
               field_options = field_options.except(:condition).merge(**column_options.slice(:align, :label))
@@ -151,7 +174,7 @@ module Plutonium
               policy = policy_for(record:)
 
               actions = resource_definition.defined_actions
-                .select { |k, a| a.collection_record_action? && !a.kanban_drop? && policy.allowed_to?(:"#{k}?") && a.condition_met?(view_context, record:) }
+                .select { |k, a| a.collection_record_action? && !a.hidden? && policy.allowed_to?(:"#{k}?") && a.condition_met?(view_context, record:) }
                 .values
 
               primary_actions = actions.select { |a| a.category.primary? }.sort_by(&:position)
@@ -176,9 +199,31 @@ module Plutonium
           end
         end
 
+        # Returns a column block that renders `inner`'s cell with the grip in
+        # front of it. Wraps rather than replaces, so a formatter, a custom
+        # column block and an inferred component all keep rendering as they did.
+        #
+        # `sort_url` is resolved ONCE, outside the per-row lambda: it depends on
+        # the collection's sort, not on the record, and building it per row would
+        # re-derive the same URL for every row of every page.
+        #
+        # The per-record `reposition?` check, by contrast, HAS to run per row.
+        # Rows that fail it render exactly as they did before, unwrapped.
+        def wrap_with_drag_handle(inner)
+          sort_url = position_grip_sort_url
+
+          ->(wrapped_object, key) {
+            record = wrapped_object.unwrapped
+            cell = inner.call(wrapped_object, key)
+            next cell unless repositionable?(record)
+
+            Plutonium::UI::Table::Components::DragHandle::Cell.new(cell, sort_url: sort_url)
+          }
+        end
+
         def bulk_actions
           @bulk_actions ||= resource_definition.defined_actions
-            .select { |k, a| a.bulk_action? && a.condition_met?(view_context) }
+            .select { |k, a| a.bulk_action? && !a.hidden? && a.condition_met?(view_context) }
             .values
         end