stimulus_plumbers 0.4.13 → 0.4.15

data/config/locales/en.yml

@@ -30,3 +30,15 @@ en:
         hide: "Hide password"
       search:
         clear: "Clear search"
+    password:
+      rules_heading: "It's better to have:"
+      rules:
+        length: "At least %{count} characters"
+        uppercase: "One uppercase letter"
+        lowercase: "One lowercase letter"
+        digit: "One number"
+        symbol: "One symbol"
+      levels:
+        weak: "Weak password"
+        fine: "Fine password"
+        strong: "Strong password"

data/docs/component/combobox.md

@@ -8,7 +8,8 @@ See [docs/component/combobox.md](../../../stimulus-plumbers/docs/component/combo
 
 ### `sp_combobox`
 
-Single entry point. The panel type is chosen by a method call on the yielded builder
+Single entry point. The panel type is chosen by a method call on the yielded
+`Combobox::Config` ([`Plumber::Config`](plumber.md#plumberconfig))
 (`c.dropdown`, `c.typeahead`, `c.date`, `c.time`) — the panel owns its `aria-haspopup`,
 popup id, trigger icon, and wrapper data. The `sp_combobox_*` helpers below are thin
 wrappers over this.
@@ -31,7 +32,7 @@ end %>
 | `close_on_select` | `false` keeps the panel open after a selection   |
 | `**html_options`  | Forwarded to the wrapper `div`                   |
 
-Builder methods: `c.dropdown(options:, value:, label:)`, `c.typeahead(options:, value:, label:, url:)`,
+Config methods: `c.dropdown(options:, value:, label:)`, `c.typeahead(options:, value:, label:, url:)`,
 `c.date(value:)`, `c.time(format:, step:, value:)`.
 
 ---

data/docs/component/form.md

@@ -108,6 +108,9 @@ Three methods render a complete, accessible field:
 <%= f.field :bio,      as: :text_area, hint: "Tell us about yourself." %>
 <%= f.field :avatar,   as: :file %>
 <%= f.field :password, as: :password, revealable: true %>
+<%= f.field :password, as: :password do |p| %>
+  <% p.enforce min_length: 12, max_length: 64 %>
+<% end %>
 <%= f.field :verification_code, as: :code, length: 6 %>
 <%= f.field :card_number, as: :credit_card %>
 <%= f.field :email,    as: :email,    floating: :filled %>
@@ -118,6 +121,8 @@ Three methods render a complete, accessible field:
       choices: ["ruby", "rails", "hotwire"], clearable: true %>
 ```
 
+`f.field` can take a block when its renderer declares `&block`; that declaration opts the renderer into the block DSL. For example, the password renderer yields a `Password::Requirements` that accepts `enforce(**options)` and `rule(...)` configuration — see **Password** below. Strength renders a `password-strength` wrapper containing the input, a native `<meter>`, a polite live level, a rules heading, and a rules list. The input references the rules list with `aria-describedby`.
+
 `choices:` takes the standard Rails shape — an array of `[label, value]` pairs (or a flat array of strings).
 
 **Floating label variants** — label starts inside the input, animates above on focus/fill. Compatible with text-like inputs only.
@@ -162,13 +167,40 @@ Use `f.search_field` for a native `<input type="search">`.
 
 **Password** (`as: :password`) — reveal-toggle wrapper backed by `input-revealable`.
 
-| Option         | Values  | Default              | Description                                 |
-| -------------- | ------- | -------------------- | ------------------------------------------- |
-| `revealable`   | Boolean | `false`              | Adds a show/hide toggle button on the input |
-| `autocomplete` | String  | `"current-password"` | Native autocomplete value                   |
+| Option         | Values                   | Default              | Description                                      |
+| -------------- | ------------------------ | -------------------- | ------------------------------------------------ |
+| `revealable`   | Boolean                  | `false`              | Adds a show/hide toggle button on the input      |
+| `autocomplete` | String                   | `"current-password"` | Native autocomplete value                        |
+| `requirements` | `Password::Requirements` | `nil`                | Prebuilt rule set that drives the strength meter |
 
 Use `f.password_field` for a plain `<input type="password">` (also accepts `revealable:`).
 
+**Strength rules.** Declare rules inline with a block, or pass a shared `requirements:` object. `enforce(min_length:, max_length:, uppercase:/lowercase:/digit:/symbol:)` enables built-ins — a character-class option takes `true` (≥1), an Integer (≥N), or a Range (`N..M` occurrences); the length rule requires **both** `min_length` and `max_length`. `rule(key, label, pattern:, min:, max:, negate:)` adds a custom rule (`negate: true` forbids matches).
+
+```erb
+<%= f.field :password, as: :password do |p| %>
+  <% p.enforce min_length: 12, max_length: 64, digit: true %>
+  <% p.rule :no_spaces, "No spaces", pattern: /\s/, negate: true %>
+<% end %>
+```
+
+**Server enforcement.** Build one `Password::Requirements` and share it between the form meter and the model validator so they cannot drift:
+
+```ruby
+PASSWORD_RULES = StimulusPlumbers::Password::Requirements.build do |r|
+  r.enforce(min_length: 12, max_length: 64, digit: true)
+end
+
+# model — PasswordStrengthValidator; valid? iff every enabled rule passes
+validates :password, password_strength: { with: PASSWORD_RULES }
+```
+
+```erb
+<%= f.field :password, as: :password, requirements: PASSWORD_RULES %>
+```
+
+The validator also accepts inline options (`password_strength: { min_length: 12, max_length: 64, digit: true }`) and a custom `message:`. For the rule-descriptor wire contract and meter behaviour, see the [JS controller doc](../../../stimulus-plumbers/docs/component/password-strength.md).
+
 **Code** (`as: :code`) — character-cell entry backed by `input-formatter` and the `character-cells` plumber. The native input remains the accessible control; cells are decorative.
 
 | Option         | Values                                   | Default                | Description                                              |

data/docs/component/plumber.md

@@ -105,7 +105,7 @@ end
 
 ## Plumber::Slots
 
-Base class for a component's slot DSL (e.g. `renderer.with_title(value)`, `renderer.with_content { ... }`). Used by `Card`, `Button`, `Link`, `List::Item`, `Timeline::Event`, and `Combobox::Builder`.
+Base class for a component's slot DSL (e.g. `renderer.with_title(value)`, `renderer.with_content { ... }`). Used by `Card`, `Button`, `Link`, `List::Item`, and `Timeline::Event`.
 
 ```ruby
 class MySlots < StimulusPlumbers::Plumber::Slots
@@ -123,6 +123,45 @@ yield slots if block_given?
 
 Slots needing custom validation (e.g. a required keyword) define `with_*` manually instead of using the `slot` DSL — see `Card::Slots#with_action`.
 
+`set_slot` is private and returns `nil`, so a `with_*` method reads as a command — hand-written setters need no trailing `nil`. Reads go through the public `resolve` / `options_for`.
+
+---
+
+## Plumber::Config
+
+Sibling of `Slots` for block DSLs whose payload is configuration rather than content. Used by `Combobox::Config`. (Password rules are **not** a `Plumber::Config` — `Password::Requirements` is a standalone model-layer object; see the password field in [form.md](form.md).)
+
+**Which one to subclass — does the block body produce markup?** Yes → `Slots`. No → `Config`.
+
+|                   | `Plumber::Slots`                                 | `Plumber::Config`                                |
+| ----------------- | ------------------------------------------------ | ------------------------------------------------ |
+| Holds             | content — blocks rendered through the view       | configuration — values, hashes, class references |
+| Template used for | `capture` (essential)                            | passing through to renderers only                |
+| Declares          | `slot :a, :b` macro, generating `with_*` setters | plain named methods                              |
+| Public read API   | `resolve` / `options_for`                        | none — subclasses expose named readers           |
+
+`Config` never captures, so it inherits no `slot` macro. Its whole store is **private**: `Slots` publishes `resolve` because its payload is uniform content a renderer reads generically, whereas a `Config`'s settings are typed, so each subclass names its own readers.
+
+```ruby
+class MyConfig < StimulusPlumbers::Plumber::Config
+  def panel(**options)
+    configure(:panel, options)        # stores, returns nil
+  end
+
+  def panel_options
+    config(:panel)                    # reads, nil when unset
+  end
+
+  def panel?
+    configured?(:panel)               # distinguishes unset from set-to-nil
+  end
+end
+```
+
+Setters return `nil` for the same reason `set_slot` does — the DSL method reads as a command.
+
+Construct with the view `template`; `Config` exposes it via `attr_reader` so subclasses can hand it to renderers (see `Combobox::Config#render_panel`).
+
 ---
 
 ## Plumber::Options::Html

data/docs/component/progress.md

@@ -1,6 +1,6 @@
 # Progress
 
-Rails helpers for rendering the `progress` Stimulus controller's three variants. See [stimulus-plumbers's docs/component/progress.md](../../../stimulus-plumbers/docs/component/progress.md) for the controller's Values/Targets/Methods/Dispatches.
+Rails helpers for rendering the `progress` Stimulus controller's four variants. See [stimulus-plumbers's docs/component/progress.md](../../../stimulus-plumbers/docs/component/progress.md) for the controller's Values/Targets/Methods/Dispatches.
 
 ## Helpers
 
@@ -23,21 +23,41 @@ width directly — this is the same with or without a theme. A theme may
 layer motion on top (Tailwind slides it); without one, the bar renders
 as a static partial fill.
 
+### `sp_progress_segmented`
+
+```erb
+<%= sp_progress_segmented(value: 6, segments: 5, max: 10, aria: { label: "Password strength" }) %>
+```
+
+Splits the track into `segments:` equal slots and distributes the value across them (max 10 with `segments: 5` → each slot spans 2 units). Renders one `fill` target per slot; the JS controller fills them.
+
+| Option           | Default     | Description                                                                                            |
+| ---------------- | ----------- | ------------------------------------------------------------------------------------------------------ |
+| `value:`         | —           | Required. Current value                                                                                |
+| `segments:`      | —           | Required. Number of equal slots                                                                        |
+| `min:`           | `0`         | Range minimum                                                                                          |
+| `max:`           | `100`       | Range maximum                                                                                          |
+| `mode:`          | `:discrete` | `:discrete` lights a whole slot once reached; `:continuous` partially fills the boundary slot          |
+| `ramp:`          | `nil`       | `:strength` colors slots danger → warning → success by position (strength meter); `nil` = single color |
+| `indeterminate:` | `false`     | Omits `aria-valuenow`; a single chunk relays across the slots, one at a time                           |
+| `**html_options` | —           | Forwarded to the outer `<div role="progressbar">`                                                      |
+
 ### `sp_progress_ring`
 
 ```erb
 <%= sp_progress_ring(value: 60, max: 100, aria: { label: "Storage used" }) %>
 ```
 
-| Option           | Default | Description                                                |
-| ---------------- | ------- | ---------------------------------------------------------- |
-| `value:`         | —       | Required. Current value                                    |
-| `min:`           | `0`     | Range minimum                                              |
-| `max:`           | `100`   | Range maximum                                              |
-| `indeterminate:` | `false` | Omits `aria-valuenow`; adds the indeterminate hook class   |
-| `**html_options` | —       | Forwarded to the rendered icon (role, aria, classes, etc.) |
+| Option           | Default | Description                                                                                   |
+| ---------------- | ------- | --------------------------------------------------------------------------------------------- |
+| `value:`         | —       | Required. Current value                                                                       |
+| `min:`           | `0`     | Range minimum                                                                                 |
+| `max:`           | `100`   | Range maximum                                                                                 |
+| `indeterminate:` | `false` | Omits `aria-valuenow`; adds the indeterminate hook class                                      |
+| `size:`          | `nil`   | `:sm` \| `:md` \| `:lg` size token; `nil` uses the icon's own size (override with `classes:`) |
+| `**html_options` | —       | Forwarded to the rendered icon (role, aria, classes, etc.)                                    |
 
-Renders via the theme's icon registry (icon name `"progress-ring"`), the same mechanism as `sp_icon`. Track/fill color and ring size are fixed by the icon's own SVG — resize with a `classes:`/`class:` override (e.g. `classes: "size-16"`) rather than a radius option. **Themes must register a `"progress-ring"` icon to render the ring's visual structure** — `stimulus-plumbers-tailwind` ships one; a theme without it (including the unstyled `Themes::Base`) falls back to an empty `<span role="progressbar">` with no visible ring, same as `sp_icon` for an unknown icon name.
+Renders via the theme's icon registry (icon name `"progress-ring"`), the same mechanism as `sp_icon`. Resize with the `size:` token (`:sm`/`:md`/`:lg`) or, for an exact size, a `classes:`/`class:` override (e.g. `classes: "size-16"`) — there is no radius option. **Themes must register a `"progress-ring"` icon to render the ring's visual structure** — `stimulus-plumbers-tailwind` ships one; a theme without it (including the unstyled `Themes::Base`) falls back to an empty `<span role="progressbar">` with no visible ring, same as `sp_icon` for an unknown icon name.
 
 When `indeterminate:` is true (and a theme provides the ring icon), the JS
 controller sets the fill circle's `stroke-dasharray` to a fixed 25% arc

data/lib/stimulus_plumbers/components/card/slots.rb

@@ -10,7 +10,6 @@ module StimulusPlumbers
           raise ArgumentError, "card.body requires a block" unless block
 
           set_slot(:body, block)
-          nil
         end
 
         # Defined manually (not via `slot` DSL) because it requires a named `url:` keyword with validation.
@@ -18,7 +17,6 @@ module StimulusPlumbers
           raise ArgumentError, "card.action requires content (string or block) when url: is given" if url && value.nil? && !block
 
           set_slot(:action, block || value, url ? { url: url } : {})
-          nil
         end
       end
     end

data/lib/stimulus_plumbers/components/combobox/{builder.rb → config.rb}

@@ -5,7 +5,7 @@ module StimulusPlumbers
     class Combobox
       # Yielded to `Combobox#render`: selects a variant renderer, then exposes its
       # `metadata` (trigger/wrapper wiring) and renders its panel body.
-      class Builder < Plumber::Slots
+      class Config < Plumber::Config
         def dropdown(**options)
           select(Dropdown, options)
         end
@@ -23,22 +23,22 @@ module StimulusPlumbers
         end
 
         def selected?
-          @slots.key?(:variant)
+          configured?(:renderer)
         end
 
         def renderer
-          selection&.fetch(:renderer)
+          config(:renderer)
         end
 
         def options
-          selection ? selection[:options] : {}
+          config(:options) || {}
         end
 
         def metadata
           renderer ? renderer::Metadata : DefaultMetadata
         end
 
-        def render_panel(template, panel_attrs:)
+        def render_panel(panel_attrs:)
           renderer&.new(template)&.render(panel_attrs: panel_attrs, **options)
         end
 
@@ -70,12 +70,8 @@ module StimulusPlumbers
         private
 
         def select(renderer, options)
-          set_slot(:variant, { renderer: renderer, options: options })
-          nil
-        end
-
-        def selection
-          resolve(:variant)
+          configure(:renderer, renderer)
+          configure(:options, options)
         end
       end
     end

data/lib/stimulus_plumbers/components/combobox.rb

@@ -9,42 +9,42 @@ module StimulusPlumbers
 
       def render(trigger: {}, input: {}, id: nil, label: nil, close_on_select: nil, **kwargs, &block)
         trigger_opts = trigger.dup
-        builder      = resolve_builder(&block)
+        config       = resolve_config(&block)
         trigger_id   = id || trigger_opts.delete(:id) || template.sp_dom_id
         panel_id     = Popover.panel_id_for(trigger_id)
 
-        template.content_tag(:div, **combobox_attrs(input, close_on_select, builder, panel_id, kwargs)) do
-          build_popover(trigger_opts, input, builder, trigger_id, panel_id, label)
+        template.content_tag(:div, **combobox_attrs(input, close_on_select, config, panel_id, kwargs)) do
+          build_popover(trigger_opts, input, config, trigger_id, panel_id, label)
         end
       end
 
       private
 
-      def resolve_builder
-        builder = Combobox::Builder.new(template)
-        yield builder if block_given?
-        builder
+      def resolve_config
+        config = Combobox::Config.new(template)
+        yield config if block_given?
+        config
       end
 
-      def build_popover(trigger, input, builder, trigger_id, panel_id, label)
-        metadata = builder.metadata
+      def build_popover(trigger, input, config, trigger_id, panel_id, label)
+        metadata = config.metadata
 
         Components::Popover.new(template).build(panel_id: panel_id) do |p|
           p.trigger(haspopup: metadata.haspopup, controls: metadata.popup_id_for(panel_id)) do |attrs|
             build_combobox_trigger(attrs, trigger, input, metadata, trigger_id, label)
           end
           p.build_panel(classes: theme.resolve(:combobox_popover).fetch(:classes, "")) do |panel_attrs|
-            builder.render_panel(template, panel_attrs: panel_attrs)
+            config.render_panel(panel_attrs: panel_attrs)
           end
         end
       end
 
-      def combobox_attrs(input, close_on_select, builder, panel_id, kwargs)
+      def combobox_attrs(input, close_on_select, config, panel_id, kwargs)
         merge_html_options(
           theme.resolve(:combobox),
           kwargs,
           { data: stimulus_data(input[:value], close_on_select) },
-          { data: builder.metadata.stimulus_data(panel_id, builder.options) }
+          { data: config.metadata.stimulus_data(panel_id, config.options) }
         )
       end
 

data/lib/stimulus_plumbers/components/password_strength.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module StimulusPlumbers
+  module Components
+    class PasswordStrength < Plumber::Base
+      LEVEL_KEYS = %i[weak fine strong].freeze
+
+      class << self
+        def meter_id_for(input_id)
+          "#{input_id}_meter"
+        end
+
+        def rules_id_for(input_id)
+          "#{input_id}_rules"
+        end
+      end
+
+      def render(input:, input_id:, config:)
+        @config = config
+        template.content_tag(:div, **wrapper_options(config, input_id)) do
+          template.safe_join([input, render_meter(input_id), render_level, render_rules_heading, render_rules(input_id)])
+        end
+      end
+
+      private
+
+      def wrapper_options(config, input_id)
+        stimulus = config.to_stimulus
+        merge_html_options(
+          theme.resolve(:password_strength_wrapper),
+          data: {
+            controller:                        "password-strength",
+            password_strength_rules_value:     stimulus[:rules].to_json,
+            password_strength_options_value:   stimulus[:options].to_json,
+            password_strength_labels_value:    stimulus[:labels].to_json,
+            password_strength_progress_outlet: "##{self.class.meter_id_for(input_id)}"
+          }
+        )
+      end
+
+      def render_meter(input_id)
+        ProgressMeter.new(template).render(value: 0, id: self.class.meter_id_for(input_id), **@config.thresholds)
+      end
+
+      def render_level
+        template.content_tag(
+          :p,
+          level_labels[:weak],
+          **merge_html_options(
+            theme.resolve(:password_strength_level),
+            data: { password_strength_target: "level" },
+            aria: { live: "polite" }
+          )
+        )
+      end
+
+      def level_labels
+        LEVEL_KEYS.index_with { |key| I18n.t("stimulus_plumbers.password.levels.#{key}") }
+      end
+
+      def render_rules_heading
+        template.content_tag(
+          :p,
+          I18n.t("stimulus_plumbers.password.rules_heading"),
+          **theme.resolve(:password_strength_rules_heading)
+        )
+      end
+
+      def render_rules(input_id)
+        html_options = merge_html_options(
+          theme.resolve(:password_strength_rules),
+          id: self.class.rules_id_for(input_id)
+        )
+        template.content_tag(:ul, **html_options) do
+          template.safe_join(@config.rules.map { |key, label| render_rule(key, label) })
+        end
+      end
+
+      def render_rule(key, label)
+        template.content_tag(
+          :li,
+          **merge_html_options(
+            theme.resolve(:password_strength_rule),
+            data: {
+              password_strength_target: "rule", rule: key, satisfied: "false"
+            }
+          )
+        ) { template.safe_join([rule_icon("check", "checkIcon", hidden: true), rule_icon("close", "closeIcon"), label]) }
+      end
+
+      def rule_icon(name, target, hidden: false)
+        Icon.new(template).render(
+          name,
+          size:   :sm,
+          aria:   { hidden: "true" },
+          data:   { password_strength_target: target },
+          hidden: hidden,
+          **theme.resolve(:password_strength_rule_icon)
+        )
+      end
+    end
+  end
+end

data/lib/stimulus_plumbers/components/progress/shared.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module StimulusPlumbers
+  module Components
+    module Progress
+      # Shared stimulus/ARIA wiring for the progress variants (bar, segmented, ring, meter).
+      module Shared
+        private
+
+        def progress_stimulus_data(value:, min:, max:, variant:, **extra)
+          {
+            data: {
+              controller:               "progress",
+              "progress-variant-value": variant,
+              "progress-current-value": value,
+              "progress-min-value":     min,
+              "progress-max-value":     max,
+              **extra
+            }
+          }
+        end
+
+        def progress_aria(value:, min:, max:, indeterminate: false)
+          aria = { valuemin: min, valuemax: max }
+          aria[:valuenow] = value unless indeterminate
+          aria
+        end
+      end
+    end
+  end
+end

data/lib/stimulus_plumbers/components/progress_bar.rb

@@ -3,47 +3,71 @@
 module StimulusPlumbers
   module Components
     class ProgressBar < Plumber::Base
+      include Progress::Shared
+
       def render(...)
         render_bar(...)
       end
 
+      def render_segmented(value:, segments:, min: 0, max: 100, mode: :discrete, indeterminate: false, ramp: nil, **kwargs)
+        html_options = merge_html_options(
+          theme.resolve(:progress_segmented),
+          kwargs,
+          progress_stimulus_data(
+            value:                          value,
+            min:                            min,
+            max:                            max,
+            variant:                        "segmented",
+            "progress-segment-mode-value":  mode,
+            "progress-indeterminate-value": indeterminate
+          ),
+          { role: "progressbar", aria: progress_aria(value: value, min: min, max: max, indeterminate: indeterminate) }
+        )
+        slots = ramp_intents(ramp, segments).map { |intent| render_segment(intent: intent) }
+        template.content_tag(:div, template.safe_join(slots), **html_options)
+      end
+
       private
 
       def render_bar(value:, min: 0, max: 100, indeterminate: false, **kwargs)
         html_options = merge_html_options(
           theme.resolve(:progress_bar),
           kwargs,
-          stimulus_data(value: value, min: min, max: max, indeterminate: indeterminate),
+          progress_stimulus_data(
+            value: value, min: min, max: max, variant: "bar", "progress-indeterminate-value": indeterminate
+          ),
           { role: "progressbar", aria: progress_aria(value: value, min: min, max: max, indeterminate: indeterminate) }
         )
         template.content_tag(:div, render_fill, **html_options)
       end
 
-      def render_fill
+      # `data-intent` is a theme-independent styling hook the theme colors via attribute variants.
+      def render_fill(intent: nil)
+        data = { "progress-target": "fill" }
+        data[:intent] = intent if intent
+        template.content_tag(:div, nil, **merge_html_options(theme.resolve(:progress_bar_fill), { data: data }))
+      end
+
+      # Slots are aria-hidden — the container owns the progressbar ARIA.
+      def render_segment(intent: nil)
         template.content_tag(
           :div,
-          nil,
-          **merge_html_options(theme.resolve(:progress_bar_fill), { data: { "progress-target": "fill" } })
+          render_fill(intent: intent),
+          **merge_html_options(theme.resolve(:progress_segment), { aria: { hidden: true } })
         )
       end
 
-      def progress_aria(value:, min:, max:, indeterminate:)
-        aria = { valuemin: min, valuemax: max }
-        aria[:valuenow] = value unless indeterminate
-        aria
-      end
+      # `:strength` buckets each slot into danger/warning/success thirds by position; nil = uncolored.
+      def ramp_intents(ramp, count)
+        return Array.new(count) unless ramp == :strength
 
-      def stimulus_data(value:, min:, max:, indeterminate:)
-        {
-          data: {
-            controller:                     "progress",
-            "progress-variant-value":       "bar",
-            "progress-current-value":       value,
-            "progress-min-value":           min,
-            "progress-max-value":           max,
-            "progress-indeterminate-value": indeterminate
-          }
-        }
+        Array.new(count) do |i|
+          case (i + 1).fdiv(count)
+          when ..(1.0 / 3) then :danger
+          when ..(2.0 / 3) then :warning
+          else :success
+          end
+        end
       end
     end
   end

data/lib/stimulus_plumbers/components/progress_meter.rb

@@ -3,6 +3,8 @@
 module StimulusPlumbers
   module Components
     class ProgressMeter < Plumber::Base
+      include Progress::Shared
+
       def render(...)
         render_meter(...)
       end
@@ -14,25 +16,25 @@ module StimulusPlumbers
         html_options = merge_html_options(
           theme.resolve(:progress_meter),
           kwargs,
-          stimulus_data(value: value, min: min, max: max, low: low, high: high, optimum: optimum),
+          progress_stimulus_data(
+            value:             value,
+            min:               min,
+            max:               max,
+            variant:           "meter",
+            "progress-target": "meter",
+            **threshold_data(low: low, high: high, optimum: optimum)
+          ),
           attrs
         )
         template.content_tag(:meter, nil, **html_options)
       end
 
-      def stimulus_data(value:, min:, max:, low:, high:, optimum:)
-        data = {
-          controller:               "progress",
-          "progress-target":        "meter",
-          "progress-variant-value": "meter",
-          "progress-current-value": value,
-          "progress-min-value":     min,
-          "progress-max-value":     max
-        }
-        data["progress-low-value"]     = low if low
-        data["progress-high-value"]    = high if high
-        data["progress-optimum-value"] = optimum if optimum
-        { data: data }
+      def threshold_data(low:, high:, optimum:)
+        data = {}
+        data[:"progress-low-value"]     = low if low
+        data[:"progress-high-value"]    = high if high
+        data[:"progress-optimum-value"] = optimum if optimum
+        data
       end
     end
   end