plutonium 0.66.0 → 0.68.0

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

@@ -41,8 +41,9 @@ module Plutonium
             link: "text-lg text-primary-600 dark:text-primary-400 hover:text-primary-500 dark:hover:text-primary-300 whitespace-pre-line transition-colors",
 
             # Color display
-            color: "flex items-center text-lg text-[var(--pu-text)] whitespace-pre-line",
-            color_indicator: "w-10 h-10 rounded-lg mr-3 shadow-sm border border-[var(--pu-border)]",
+            color: "flex items-center gap-2",
+            color_indicator: "w-6 h-6 rounded border border-[var(--pu-border)]",
+            color_label: "text-sm text-[var(--pu-text-muted)]",
 
             # Boolean / badge pills — variant class is applied by the component.
             boolean: "",
@@ -57,6 +58,27 @@ module Plutonium
             json: "text-sm text-[var(--pu-text)] whitespace-pre font-mono bg-[var(--pu-surface-alt)] border border-[var(--pu-border-muted)] rounded-[var(--pu-radius-md)] p-4 overflow-x-auto",
             prefixed_icon: "w-6 h-6 mr-2 text-[var(--pu-text-muted)]",
             markdown: "format dark:format-invert format-primary max-w-none",
+            rich_text: "format dark:format-invert format-primary max-w-none",
+            key_value: "grid grid-cols-[auto_1fr] gap-x-6 gap-y-2 text-[var(--pu-text)]",
+            key_value_key: "font-medium text-[var(--pu-text-muted)] break-words",
+            key_value_value: "break-words",
+            key_value_nested: "font-mono text-sm",
+            list: "flex flex-wrap gap-1.5",
+            list_item: "pu-badge pu-badge-neutral",
+            relative_time: "text-lg text-[var(--pu-text)]",
+            code: "flex items-center gap-2",
+            code_value: "font-mono text-sm text-[var(--pu-text)] bg-[var(--pu-surface-alt)] border border-[var(--pu-border-muted)] rounded-[var(--pu-radius-sm)] px-2 py-0.5 break-all",
+            code_copy: "pu-btn pu-btn-xs pu-btn-ghost",
+            duration: "text-lg text-[var(--pu-text)] tabular-nums",
+            file_size: "text-lg text-[var(--pu-text)] tabular-nums",
+            progress: "flex items-center gap-3",
+            progress_track: "h-2 w-full max-w-xs rounded-full bg-[var(--pu-surface-alt)] overflow-hidden",
+            progress_bar: "h-full rounded-full bg-primary-500",
+            progress_label: "text-sm text-[var(--pu-text-muted)] tabular-nums",
+            rating: "flex items-center gap-0.5",
+            rating_filled: "w-5 h-5 text-warning-500 fill-current",
+            rating_empty: "w-5 h-5 text-[var(--pu-border)]",
+            binary: "text-sm text-[var(--pu-text-muted)]",
 
             # Attachments
             attachment_value_wrapper: "grid grid-cols-[repeat(auto-fill,minmax(0,200px))] gap-4",

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

@@ -43,6 +43,11 @@ module Plutonium
           end
           alias_method :markdown_tag, :easymde_tag
 
+          # Action Text editor (Trix, or Lexxy when installed). See {Components::RichText}.
+          def rich_text_tag(**, &)
+            create_component(Components::RichText, :rich_text, **, &)
+          end
+
           def toggle_tag(**, &)
             create_component(Plutonium::UI::Form::Components::Toggle, :toggle, **, &)
           end
@@ -54,12 +59,30 @@ module Plutonium
           def password_tag(**, &)
             create_component(Components::Password, :password, **, &)
           end
+          alias_method :secret_tag, :password_tag
 
           def slim_select_tag(**attributes, &)
             attributes[:data_controller] = tokens(attributes[:data_controller], "slim-select")
             select_tag(**attributes, required: false, class!: "", &)
           end
 
+          # Chip input for array values. See {Components::List}.
+          def list_tag(**attributes, &)
+            attributes[:data_controller] = tokens(attributes[:data_controller], "slim-select")
+            create_component(Components::List, :select, required: false, class!: "", **attributes, &)
+          end
+
+          # Chip input for a no_fly_list `has_tags` context. See {Components::Tags}.
+          def tags_tag(**attributes, &)
+            attributes[:data_controller] = tokens(attributes[:data_controller], "slim-select")
+            create_component(Components::Tags, :select, required: false, class!: "", **attributes, &)
+          end
+
+          # Star picker. See {Components::Rating}.
+          def rating_tag(**, &)
+            create_component(Components::Rating, :rating, **, &)
+          end
+
           def flatpickr_tag(**, &)
             create_component(Components::Flatpickr, :flatpickr, **, &)
           end
@@ -86,6 +109,10 @@ module Plutonium
             alias_method :"#{name}_tag", :uppy_tag
           end
 
+          def binary_tag(**, &)
+            create_component(Components::Binary, :file, **, &)
+          end
+
           def key_value_store_tag(**, &)
             create_component(Components::KeyValueStore, :key_value_store, **, &)
           end
@@ -116,6 +143,29 @@ module Plutonium
           alias_method :belongs_to_tag, :secure_association_tag
           alias_method :has_many_tag, :secure_association_tag
           alias_method :has_one_tag, :secure_association_tag
+          # phlexi bound this to ITS has_many_tag at definition time, so it
+          # has to be re-pointed explicitly or habtm skips the policy scope.
+          alias_method :has_and_belongs_to_many_tag, :secure_association_tag
+
+          # List-style variants of the association input: one control per
+          # authorized record instead of a slim-select. Same policy scoping,
+          # SGID validation and inline "+" add button.
+          def secure_association_checkboxes_tag(**, &)
+            create_component(Components::SecureAssociationCheckboxes, :association_checkboxes, **, &)
+          end
+          alias_method :association_checkboxes_tag, :secure_association_checkboxes_tag
+
+          def secure_association_toggles_tag(**, &)
+            create_component(Components::SecureAssociationToggles, :association_toggles, **, &)
+          end
+          alias_method :association_toggles_tag, :secure_association_toggles_tag
+          alias_method :association_switches_tag, :secure_association_toggles_tag
+
+          def secure_association_radio_buttons_tag(**, &)
+            create_component(Components::SecureAssociationRadioButtons, :association_radio_buttons, **, &)
+          end
+          alias_method :association_radio_buttons_tag, :secure_association_radio_buttons_tag
+          alias_method :association_radios_tag, :secure_association_radio_buttons_tag
 
           def secure_polymorphic_association_tag(**attributes, &)
             attributes[:data_controller] = tokens(attributes[:data_controller], "slim-select") # TODO: put this behind a config
@@ -134,7 +184,6 @@ module Plutonium
           alias_method :datetime_tag, :flatpickr_tag
           alias_method :date_tag, :flatpickr_tag
           alias_method :time_tag, :flatpickr_tag
-          alias_method :rich_text_tag, :markdown_tag
           alias_method :json_tag, :json_input_tag
           alias_method :jsonb_tag, :json_input_tag
           alias_method :hstore_tag, :key_value_store_tag

data/lib/plutonium/ui/form/components/binary.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Plutonium
+  module UI
+    module Form
+      module Components
+        # File input for a `binary` column: the uploaded file's bytes become
+        # the value. Choosing no file extracts nil, which the resource
+        # controller compacts away, so an edit that doesn't replace the file
+        # keeps the stored bytes. There is no way to clear the column here.
+        class Binary < Phlexi::Form::Components::FileInput
+          protected
+
+          def build_input_attributes
+            super
+            apply_default_hint
+          end
+
+          def normalize_input(input_value)
+            input_value.read if input_value.is_a?(ActionDispatch::Http::UploadedFile)
+          end
+
+          private
+
+          # Says what a blank submit keeps: the bytes in the database, not a
+          # rejected upload still assigned to the record on a failed re-render.
+          def apply_default_hint
+            return if field.has_hint?
+
+            stored = field.object.attribute_in_database(field.key) if field.object.persisted?
+            return if stored.blank?
+
+            size = ActiveSupport::NumberHelper.number_to_human_size(stored.bytesize)
+            field.hint(Plutonium::Translation.t("plutonium.ui.form.binary.replace_hint", size:))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/plutonium/ui/form/components/key_value_store.rb

@@ -44,21 +44,6 @@ module Plutonium
             attributes[:data][:key_value_store_limit_value] = limit
           end
 
-          def render_header
-            div(class: "key-value-store-header") do
-              if attributes[:label]
-                h3(class: "text-lg font-semibold text-[var(--pu-text)]") do
-                  plain attributes[:label]
-                end
-              end
-              if attributes[:description]
-                p(class: "text-sm text-[var(--pu-text-muted)]") do
-                  plain attributes[:description]
-                end
-              end
-            end
-          end
-
           def render_key_value_pairs
             # Hidden sentinel input ensures the field is always present in params when the
             # component is rendered. Without this, removing all pairs would submit nothing,
@@ -75,42 +60,37 @@ module Plutonium
 
           def render_key_value_pair(key, value, index)
             div(
-              class: "key-value-pair flex items-center gap-2 p-2 border border-[var(--pu-border)] rounded-[var(--pu-radius-sm)]",
+              class: "key-value-pair flex items-center gap-2",
               data_key_value_store_target: "pair"
             ) do
-              # Key input
-              input(
-                type: :text,
-                placeholder: Plutonium::Translation.t("plutonium.ui.form.key_value_store.key_placeholder"),
-                value: key,
-                name: "#{field_name}[#{index}][key]",
-                id: "#{field.dom.id}_#{index}_key",
-                class: "flex-1 px-3 py-1 text-sm border border-[var(--pu-border)] rounded-[var(--pu-radius-sm)] focus:ring-2 focus:ring-primary-500 focus:border-primary-500 bg-[var(--pu-surface)] text-[var(--pu-text)]",
-                data_key_value_store_target: "keyInput"
-              )
-
-              # Value input
-              input(
-                type: :text,
-                placeholder: Plutonium::Translation.t("plutonium.ui.form.key_value_store.value_placeholder"),
-                value: value,
-                name: "#{field_name}[#{index}][value]",
-                id: "#{field.dom.id}_#{index}_value",
-                class: "flex-1 px-3 py-1 text-sm border border-[var(--pu-border)] rounded-[var(--pu-radius-sm)] focus:ring-2 focus:ring-primary-500 focus:border-primary-500 bg-[var(--pu-surface)] text-[var(--pu-text)]",
-                data_key_value_store_target: "valueInput"
-              )
-
-              # Remove button
+              render_pair_input(:key, key, index)
+              render_pair_input(:value, value, index)
+
               button(
                 type: :button,
-                class: "px-2 py-1 text-danger-600 hover:text-danger-800 focus:outline-none transition-colors",
+                class: "pu-btn pu-btn-sm pu-btn-ghost text-danger-600 dark:text-danger-400",
+                aria_label: Plutonium::Translation.t("plutonium.ui.form.key_value_store.remove_pair"),
                 data_action: "key-value-store#removePair"
               ) do
-                plain "×"
+                render Phlex::TablerIcons::X.new(class: "w-4 h-4")
               end
             end
           end
 
+          # `part` is :key or :value. The template row passes "__INDEX__", which
+          # the controller swaps for the real index when it clones the row.
+          def render_pair_input(part, value, index)
+            input(
+              type: :text,
+              placeholder: Plutonium::Translation.t("plutonium.ui.form.key_value_store.#{part}_placeholder"),
+              value:,
+              name: "#{field_name}[#{index}][#{part}]",
+              id: "#{field.dom.id}_#{index}_#{part}",
+              class: "pu-input flex-1 min-w-0",
+              data_key_value_store_target: "#{part}Input"
+            )
+          end
+
           def render_add_button
             div(class: "key-value-store-actions mt-2") do
               button(
@@ -129,36 +109,7 @@ module Plutonium
 
           def render_template
             template(data_key_value_store_target: "template") do
-              div(
-                class: "key-value-pair flex items-center gap-2 p-2 border border-[var(--pu-border)] rounded-[var(--pu-radius-sm)]",
-                data_key_value_store_target: "pair"
-              ) do
-                input(
-                  type: :text,
-                  placeholder: Plutonium::Translation.t("plutonium.ui.form.key_value_store.key_placeholder"),
-                  name: "#{field_name}[__INDEX__][key]",
-                  id: "#{field.dom.id}___INDEX___key",
-                  class: "flex-1 px-3 py-1 text-sm border border-[var(--pu-border)] rounded-[var(--pu-radius-sm)] focus:ring-2 focus:ring-primary-500 focus:border-primary-500 bg-[var(--pu-surface)] text-[var(--pu-text)]",
-                  data_key_value_store_target: "keyInput"
-                )
-
-                input(
-                  type: :text,
-                  placeholder: Plutonium::Translation.t("plutonium.ui.form.key_value_store.value_placeholder"),
-                  name: "#{field_name}[__INDEX__][value]",
-                  id: "#{field.dom.id}___INDEX___value",
-                  class: "flex-1 px-3 py-1 text-sm border border-[var(--pu-border)] rounded-[var(--pu-radius-sm)] focus:ring-2 focus:ring-primary-500 focus:border-primary-500 bg-[var(--pu-surface)] text-[var(--pu-text)]",
-                  data_key_value_store_target: "valueInput"
-                )
-
-                button(
-                  type: :button,
-                  class: "px-2 py-1 text-danger-600 hover:text-danger-800 focus:outline-none transition-colors",
-                  data_action: "key-value-store#removePair"
-                ) do
-                  plain "×"
-                end
-              end
+              render_key_value_pair(nil, nil, "__INDEX__")
             end
           end
 

data/lib/plutonium/ui/form/components/list.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Plutonium
+  module UI
+    module Form
+      module Components
+        # An array value edited as chips: a multi-select (slim-select) whose
+        # options are the current values plus any `suggestions:`.
+        #
+        #   addable: false  only suggestions can be picked (default: values
+        #                   can be typed in)
+        #   limit: 5        caps the number of chips
+        class List < Phlexi::Form::Components::Select
+          protected
+
+          def build_attributes
+            @suggestions = Array(attributes.delete(:suggestions))
+            @limit = attributes.delete(:limit)
+            @addable = attributes.delete(:addable) != false
+
+            attributes[:multiple] = true
+            attributes[:choices] ||= (current_values + @suggestions.map(&:to_s)).uniq
+            attributes[:data_slim_select_addable_value] = "true" if @addable
+            attributes[:data_slim_select_max_selected_value] = @limit if @limit
+            super
+          end
+
+          def current_values = Array(field.value).map(&:to_s)
+
+          def selected?(option) = current_values.include?(option.to_s)
+
+          # Selecting nothing submits the hidden "" alone, which clears the list.
+          def normalize_input(input_value)
+            super&.reject(&:blank?)
+          end
+
+          # Typed-in values aren't among the rendered choices, so only a
+          # non-addable list restricts the submission to them.
+          def normalize_simple_input(input_value)
+            @addable ? input_value&.to_s : super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/plutonium/ui/form/components/rating.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Plutonium
+  module UI
+    module Form
+      module Components
+        # A star picker: one radio per star, no JS. The radios run from `max:`
+        # (default 5) down to 1 in a row-reversed flex box, so `.pu-rating`'s
+        # `:checked ~ label` and `:hover ~ label` rules fill the stars up to
+        # the chosen or hovered one. An optional rating ends with a "Clear"
+        # radio (blank value); it comes last so no fill rule reaches it.
+        class Rating < Phlexi::Form::Components::Base
+          include Phlexi::Form::Components::Concerns::HandlesInput
+
+          def view_template
+            fieldset(id: attributes[:id], class: tokens("pu-rating", attributes[:class]), role: :radiogroup) do
+              @max.downto(1) do |score|
+                id = "#{attributes[:id]}_#{score}"
+                input(type: :radio, id:, name: attributes[:name], value: score, checked: field.value.to_i == score,
+                  required: attributes[:required], disabled: attributes[:disabled], class: "sr-only")
+                label(for: id, title: star_label(score)) do
+                  render Phlex::TablerIcons::Star.new
+                  span(class: "sr-only") { star_label(score) }
+                end
+              end
+              render_clear unless attributes[:required]
+            end
+          end
+
+          protected
+
+          def build_attributes
+            super
+            @max = attributes.delete(:max) || 5
+          end
+
+          private
+
+          def render_clear
+            id = "#{attributes[:id]}_clear"
+            input(type: :radio, id:, name: attributes[:name], value: "", checked: field.value.blank?,
+              disabled: attributes[:disabled], class: "sr-only")
+            label(for: id, class: "pu-rating-clear") { Plutonium::Translation.t("plutonium.ui.form.rating.clear") }
+          end
+
+          def star_label(score) = Plutonium::Translation.t("plutonium.ui.display.rating.label", value: score, max: @max)
+        end
+      end
+    end
+  end
+end

data/lib/plutonium/ui/form/components/rich_text.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Plutonium
+  module UI
+    module Form
+      module Components
+        # A `has_rich_text` field, rendered through Action Text's own helper:
+        # Trix by default, Lexxy once the app adds the lexxy gem (which takes
+        # over the helper). The editor's JS comes from the app's bundle.
+        class RichText < Phlexi::Form::Components::Base
+          include Phlexi::Form::Components::Concerns::HandlesInput
+
+          def view_template
+            raw(safe(helpers.rich_text_area_tag(attributes[:name], field.value, id: attributes[:id], required: attributes[:required])))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/plutonium/ui/form/components/secure_association.rb

@@ -87,14 +87,25 @@ module Plutonium
             uri.to_s
           end
 
+          # Capped at `choice_limit`, plus the records the field holds now:
+          # one past the cap or outside the viewer's scope would otherwise not
+          # render, and saving the form would drop it (a select falls back to
+          # its blank option, an unrendered checkbox is not submitted).
           def choices
             @choices ||= begin
               collection = @raw_choices || authorized_relation
-              collection = collection.limit(@choice_limit) if @choice_limit && collection.respond_to?(:limit)
+              if collection.is_a?(ActiveRecord::Relation)
+                collection = collection.limit(@choice_limit) if @choice_limit
+                collection = (collection.to_a + selected_records).uniq
+              end
               build_choice_mapper(collection)
             end
           end
 
+          def selected_records
+            @selected_records ||= Array(field.object.public_send(association_reflection.name))
+          end
+
           # Builds the authorized association relation. Shared by `choices`
           # (which then applies `choice_limit`) and `normalize_simple_input`
           # (which validates against the full set so typeahead picks beyond
@@ -106,8 +117,11 @@ module Plutonium
             authorized_resource_scope(klass, relation: relation)
           end
 
+          # AssociationBase#build_attributes already calls
+          # build_association_attributes. Calling it here too ran it twice, and
+          # the second pass re-read the keys the first had deleted, silently
+          # dropping `skip_authorization:` and `add_action:`.
           def build_attributes
-            build_association_attributes
             super
             # Stash; the URL helper needs view_context which only exists
             # once we're rendering.
@@ -163,8 +177,16 @@ module Plutonium
           # not include records reachable via typeahead). For explicit
           # `@raw_choices`, fall back to membership in the rendered list.
           def normalize_simple_input(input_value)
+            # An explicit blank (the select's blank option, a "None" radio)
+            # clears a singular association: "" survives resource_params'
+            # `compact` and `<name>_sgid = ""` locates nil. A field that was not
+            # submitted arrives as nil and is left alone.
+            return "" if input_value == "" && !attributes[:multiple]
+
             sgid = SignedGlobalID.parse(input_value.presence)
             return nil unless sgid
+            # Keeping what the field already holds is not a new grant.
+            return sgid if selected_records.map(&:to_global_id).include?(sgid)
 
             if @raw_choices
               @signed_global_ids ||= choices.values.map { |choice| SignedGlobalID.parse(choice) }
@@ -177,13 +199,14 @@ module Plutonium
             nil
           end
 
+          # Compared as URI strings: URI objects don't match by value in a Set.
           def selected?(option)
-            case association_reflection.macro
-            when :belongs_to, :has_one
-              singular_field_value == SignedGlobalID.parse(option)
-            when :has_many, :has_and_belongs_to_many
-              collection_field_value.any? { |item| item == SignedGlobalID.parse(option) }
-            end
+            selected_gids.include?(SignedGlobalID.parse(option)&.uri&.to_s)
+          end
+
+          def selected_gids
+            @selected_gids ||= Array(attributes[:multiple] ? collection_field_value : singular_field_value)
+              .compact.to_set { |sgid| sgid.uri.to_s }
           end
 
           def singular_field_value

data/lib/plutonium/ui/form/components/secure_association_checkboxes.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Plutonium
+  module UI
+    module Form
+      module Components
+        # A has_many / habtm association rendered as one checkbox per authorized
+        # record (`input :tags, as: :association_checkboxes`).
+        class SecureAssociationCheckboxes < SecureAssociationChoices
+          protected
+
+          def control_type = :checkbox
+
+          def control_theme = :association_checkbox
+
+          def supported_macros = %i[has_many has_and_belongs_to_many]
+
+          # Unchecked boxes are not submitted, so without this blank value
+          # clearing every box would leave the param out entirely and keep the
+          # existing records. The blank is dropped by normalize_array_input.
+          # Disabled with the list: a disabled list submits no boxes, so a live
+          # blank would save as "no records" and wipe the association.
+          def render_hidden_input
+            input(type: :hidden, name: attributes[:name], value: "", autocomplete: "off", hidden: true, disabled: attributes[:disabled])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/plutonium/ui/form/components/secure_association_choices.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module Plutonium
+  module UI
+    module Form
+      module Components
+        # Abstract base for the list-style association inputs: every choice is
+        # rendered as its own control (checkbox, toggle or radio button) instead
+        # of an option inside a slim-select.
+        #
+        # Everything that makes the association input "secure" is inherited from
+        # {SecureAssociation} unchanged: the choices come from the policy-scoped
+        # relation (or `choices:`), each value is a signed global id, submitted
+        # ids are validated against the authorized relation, and the inline "+"
+        # add button still renders. Only the markup differs.
+        #
+        # Subclasses declare the control's input type, the macros they accept and
+        # the theme key their controls style off.
+        class SecureAssociationChoices < SecureAssociation
+          def view_template
+            div(class: "flex items-start space-x-1") do
+              # The wrapper's <label for=> points at this id, but a label can't
+              # name a div, so the group carries the field label itself.
+              div(**group_attributes) do
+                render_hidden_input
+                render_blank_choice if include_blank?
+                render_choices
+              end
+              render_add_button
+            end
+          end
+
+          protected
+
+          # The type attribute of each control: "checkbox" or "radio".
+          def control_type = raise(NotImplementedError, "#{self.class}#control_type")
+
+          # Theme key the individual controls style off.
+          def control_theme = raise(NotImplementedError, "#{self.class}#control_theme")
+
+          # Association macros this variant can represent.
+          def supported_macros = raise(NotImplementedError, "#{self.class}#supported_macros")
+
+          def group_role = "group"
+
+          # Everything the caller passed (data-*, aria-*, ...) lands on the
+          # group; what belongs to a form control goes on each choice instead.
+          CONTROL_ATTRIBUTES = %i[name required disabled multiple size autofocus form value].freeze
+
+          def group_attributes
+            mix(attributes.except(*CONTROL_ATTRIBUTES), {role: group_role, aria: {label: field.label}})
+          end
+
+          def build_association_attributes
+            super
+
+            unless supported_macros.include?(association_reflection.macro)
+              raise ArgumentError,
+                "#{self.class.name.demodulize} does not support #{association_reflection.macro} " \
+                "associations (#{association_name}). Supported: #{supported_macros.join(", ")}."
+            end
+
+            if association_reflection.polymorphic?
+              raise ArgumentError, "#{self.class.name.demodulize} does not support polymorphic associations (#{association_name})."
+            end
+          end
+
+          def association_name = "#{field.object.class.name}##{association_reflection.name}"
+
+          def build_attributes
+            super
+            if @group_method
+              raise ArgumentError, "#{self.class.name.demodulize} does not support group_method: (#{association_name})."
+            end
+
+            # Typeahead drives a slim-select dropdown; a rendered list has no
+            # search box to wire it to.
+            @typeahead_option = false
+          end
+
+          def render_choices
+            if choices.values.empty?
+              p(class: "pu-hint") { Plutonium::Translation.t("plutonium.ui.form.association_choices.empty") }
+              return
+            end
+
+            choices.each.with_index do |(value, text), index|
+              render_choice(value:, text:, id: "#{attributes[:id]}_#{index}", checked: selected?(value), autofocus: index.zero? && attributes[:autofocus])
+            end
+          end
+
+          def render_choice(value:, text:, id:, checked:, autofocus: false)
+            label(for: id, class: themed(:association_choice_label, field)) do
+              input(
+                type: control_type,
+                id:,
+                name: attributes[:name],
+                value:,
+                checked:,
+                required: control_required?,
+                disabled: attributes[:disabled],
+                form: attributes[:form],
+                autofocus:,
+                class: themed(control_theme, field)
+              )
+              span { text }
+            end
+          end
+
+          def render_hidden_input
+          end
+
+          def render_blank_choice
+          end
+
+          def include_blank? = false
+
+          def control_required? = false
+        end
+      end
+    end
+  end
+end