stimulus_plumbers 0.4.11 → 0.4.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d5e0d3bcf8e99d854f9ec64f1831c969a83f0e658f8b0bb7704e51129e24743a
-  data.tar.gz: '01789f5f50ccfa6cf83acde5ff4d4f61fb15552f49212742c39fe3540600b487'
+  metadata.gz: daf604780fb07315e9c562c6a3c9d4ea0cb054c03236c0947e1a58ed0d100ba0
+  data.tar.gz: abbb7e4dbe89695cd04a6c1951d1c693ac3c24bcc45d3ccace964c62b1fec6ac
 SHA512:
-  metadata.gz: 5f16ccf7913cc4122ce9eb12c50d8e39470007ac60bfafc211cd7fb3bba2b22d20ffaaf50ecc1ac31889c0cb85df35dc17b7f649cbc4c72d49b826c62d6797a3
-  data.tar.gz: af073d3c389b348b2b312d2616e55f4d921fd09a949684e5517b37483d33f9d707f893a3f1e5019e5a2265f21b346d7fbdd2c06d67978391bd54a904929bba77
+  metadata.gz: a99f6ebfbbb8e7aa0bfb273926f6828a82fb463b19407ef84f9d145d5e7f59aa14486f0388fc1aad96c6a76cd1508edae469f42bf3e2274915037e5faf2875d3
+  data.tar.gz: 33a5f7f61e581f30604a9f6a49c55d2b244f52aa0d52283c0c114e57e45adca7dee6013bdc7072a9c511d42edd96cbd1ec01d18ac476bbfd1a5dd4d675e3748e

data/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 All notable changes to this project will be documented in this file. See [conventional commits](https://www.conventionalcommits.org/) for commit guidelines.
 
+---
+## [0.4.11](https://github.com/ryancyq/stimulus-plumbers/compare/stimulus-plumbers-rails/v0.4.10..stimulus-plumbers-rails/v0.4.11) - 2026-07-19
+
+### Bug Fixes
+
+- tailwind source being committed with machine path. migrate to generated source file which should be gitignored + import the generated file in css entry point file instead. ([#180](https://github.com/ryancyq/stimulus-plumbers/issues/180)) - ([347e6ed](https://github.com/ryancyq/stimulus-plumbers/commit/347e6edeee92571f4f2fe7e509b5eed8fd0f2893)) - Ryan Chang
+
 ---
 ## [0.4.10](https://github.com/ryancyq/stimulus-plumbers/compare/stimulus-plumbers-rails/v0.4.9..stimulus-plumbers-rails/v0.4.10) - 2026-07-19
 

data/docs/architecture.md

@@ -26,6 +26,6 @@ Validation ranges for theme schema params live under `lib/stimulus_plumbers/them
 
 `Button#build_button` and `Link#build_content` always wrap non-nil text/block content in `<span>`. When content is nil and no block is given (icon-only), no `<span>` is rendered.
 
-The active theme uses `:has(> span)` / `:not(:has(> span))` CSS to distinguish icon-only from text buttons without any Ruby flag.
+The active theme uses `:has(> span)` / `:not(:has(> span))` CSS to distinguish icon-only from text buttons without any Ruby flag. Submit buttons with visually hidden text additionally use `:has(> span[data-sp-label-hidden])` so they retain the icon-only square layout while keeping an accessible name.
 
 **Do not change this contract** without updating `stimulus-plumbers-tailwind`'s `Button::LAYOUT` and `Link::BUTTON` constants accordingly. See [tailwind architecture doc](../../stimulus-plumbers-tailwind/docs/architecture.md#icon-only-square-pattern).

data/docs/component/form.md

@@ -55,6 +55,25 @@ Special options on native helpers:
 | `password_field` | `revealable: true` | Wraps input in an `input-formatter` reveal controller              |
 | `search_field`   | `clearable: true`  | Wraps input in an `input-clearable` controller with a clear button |
 
+### f.submit
+
+`f.submit` renders a themed `<button type="submit">` without a field wrapper.
+
+```erb
+<%= f.submit "Save" %>
+<%= f.submit "Save", icon_leading: "save" %>
+<%= f.submit "Continue", icon_trailing: "arrow-right" %>
+<%= f.submit "Save", icon_leading: "save", hide_label: true %>
+```
+
+| Option                             | Description                                                                                                                                                                      |
+| ---------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `type:` / `variant:`               | Button theme type and variant.                                                                                                                                                   |
+| `icon_leading:` / `icon_trailing:` | Decorative icon name placed before or after the submit text.                                                                                                                     |
+| `hide_label: true`                 | Visually hides the button's own text span while keeping it available to screen readers. This differs from `Form::Field#hide_label`, which hides an associated `<label>` element. |
+
+Submit buttons need an accessible name: pass non-blank text, or an `aria` label such as `aria: { label: "Save changes" }`.
+
 ---
 
 ## Level 2 — Full-field helpers
@@ -151,21 +170,23 @@ Use `f.password_field` for a plain `<input type="password">` (also accepts `reve
 
 **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                                 |
-| -------------- | ---------------------------------------- | ---------------------- | ------------------------------------------- |
-| `length`       | positive Integer                         | required               | Number of cells and input maximum length    |
-| `charset`      | `:digits` / `:letters` / `:alphanumeric` | `:digits`              | Allowed code characters                     |
-| `groups`       | Array of positive Integers               | `[]`                   | Visual cell groups; must add up to `length` |
-| `autocomplete` | String                                   | `"one-time-code"`      | Native autocomplete value                   |
-| `inputmode`    | String                                   | `"numeric"` for digits | Native input mode                           |
-
-**Credit card** (`as: :credit_card`) — grouped card-number entry backed by `input-formatter` and the `character-cells` plumber (grouped mode). Renders one cell per group with a literal dash separator between cells; their sum sets `maxlength`.
-
-| Option         | Values                     | Default        | Description                                                                  |
-| -------------- | -------------------------- | -------------- | ---------------------------------------------------------------------------- |
-| `groups`       | Array of positive Integers | `[4, 4, 4, 4]` | Cell groups — one cell per group, dash-separated; their sum sets `maxlength` |
-| `autocomplete` | String                     | `"cc-number"`  | Native autocomplete value                                                    |
-| `inputmode`    | String                     | `"numeric"`    | Native input mode                                                            |
+| Option         | Values                                   | Default                | Description                                              |
+| -------------- | ---------------------------------------- | ---------------------- | -------------------------------------------------------- |
+| `length`       | positive Integer                         | required               | Number of cells and input maximum length                 |
+| `charset`      | `:digits` / `:letters` / `:alphanumeric` | `:digits`              | Allowed code characters                                  |
+| `groups`       | Array of positive Integers               | `[]`                   | Visual cell groups; must add up to `length`              |
+| `separator`    | String / `nil`                           | `nil`                  | Character between groups; `nil` shows the break as a gap |
+| `autocomplete` | String                                   | `"one-time-code"`      | Native autocomplete value                                |
+| `inputmode`    | String                                   | `"numeric"` for digits | Native input mode                                        |
+
+**Credit card** (`as: :credit_card`) — grouped card-number entry backed by `input-formatter` and the `character-cells` plumber (grouped mode). Renders one cell per group; their sum sets `maxlength`.
+
+| Option         | Values                     | Default        | Description                                                  |
+| -------------- | -------------------------- | -------------- | ------------------------------------------------------------ |
+| `groups`       | Array of positive Integers | `[4, 4, 4, 4]` | Cell groups — one cell per group; their sum sets `maxlength` |
+| `separator`    | String / `nil`             | `nil`          | Character between cells; `nil` renders none                  |
+| `autocomplete` | String                     | `"cc-number"`  | Native autocomplete value                                    |
+| `inputmode`    | String                     | `"numeric"`    | Native input mode                                            |
 
 Character-cell fields do not support `floating:` labels.
 

data/docs/guide.md

@@ -12,7 +12,8 @@ Use `StimulusPlumbers::Form::Builder` (set `config.action_view.default_form_buil
 - **Level 1.** Native helper overrides (`f.text_field`, `f.select`, `f.check_box`, ...) render
   only the themed input element — use when you control the surrounding markup.
 
-Submit with `f.submit` (themed button).
+Submit with `f.submit` (themed button; supports `icon_leading:`/`icon_trailing:` and
+`hide_label:` for an icon-only button — see [docs/component/form.md](component/form.md)).
 
 ## Building views
 

data/lib/stimulus_plumbers/components/button/icon_layout.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module StimulusPlumbers
+  module Components
+    class Button < Plumber::Base
+      module IconLayout
+        private
+
+        def build_layout(slots, &block)
+          @template.safe_join(
+            [
+              render_icon_slot(slots, :icon_leading),
+              @template.capture(&block),
+              render_icon_slot(slots, :icon_trailing)
+            ]
+          )
+        end
+
+        def render_icon_slot(slots, name)
+          slots.resolve(name) do |value|
+            next value unless Components::Icon.icon_name?(value)
+
+            Components::Icon.new(@template).render(
+              name:    value,
+              size:    :sm,
+              classes: theme.resolve(:button_icon).fetch(:classes, ""),
+              aria:    { hidden: "true" }
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/stimulus_plumbers/components/button.rb

@@ -3,6 +3,8 @@
 module StimulusPlumbers
   module Components
     class Button < Plumber::Base
+      include IconLayout
+
       def render(content = nil, icon_leading: nil, icon_trailing: nil, **kwargs, &block)
         slots = Button::Slots.new(template)
         slots.with_icon_leading(icon_leading) if icon_leading
@@ -34,29 +36,6 @@ module StimulusPlumbers
           template.content_tag(:span, content)
         end
       end
-
-      def build_layout(slots, &block)
-        template.safe_join(
-          [
-            render_icon_slot(slots, :icon_leading),
-            template.capture(&block),
-            render_icon_slot(slots, :icon_trailing)
-          ]
-        )
-      end
-
-      def render_icon_slot(slots, name)
-        slots.resolve(name) do |value|
-          next value unless Components::Icon.icon_name?(value)
-
-          Components::Icon.new(template).render(
-            name:    value,
-            size:    :sm,
-            classes: theme.resolve(:button_icon).fetch(:classes, ""),
-            aria:    { hidden: "true" }
-          )
-        end
-      end
     end
   end
 end

data/lib/stimulus_plumbers/components/combobox/builder.rb

@@ -6,15 +6,37 @@ module StimulusPlumbers
       # Yielded to `Combobox#render`: selects a variant renderer, then exposes its
       # `metadata` (trigger/wrapper wiring) and renders its panel body.
       class Builder < Plumber::Slots
-        def dropdown(**options)  = select(Dropdown, options)
-        def typeahead(**options) = select(Typeahead, options)
-        def date(**options)      = select(Date, options)
-        def time(**options)      = select(Time, options)
+        def dropdown(**options)
+          select(Dropdown, options)
+        end
+
+        def typeahead(**options)
+          select(Typeahead, options)
+        end
+
+        def date(**options)
+          select(Date, options)
+        end
 
-        def selected? = @slots.key?(:variant)
-        def renderer  = selection&.fetch(:renderer)
-        def options   = selection ? selection[:options] : {}
-        def metadata  = renderer ? renderer::Metadata : DefaultMetadata
+        def time(**options)
+          select(Time, options)
+        end
+
+        def selected?
+          @slots.key?(:variant)
+        end
+
+        def renderer
+          selection&.fetch(:renderer)
+        end
+
+        def options
+          selection ? selection[:options] : {}
+        end
+
+        def metadata
+          renderer ? renderer::Metadata : DefaultMetadata
+        end
 
         def render_panel(template, panel_attrs:)
           renderer&.new(template)&.render(panel_attrs: panel_attrs, **options)
@@ -24,11 +46,25 @@ module StimulusPlumbers
         module DefaultMetadata
           module_function
 
-          def haspopup = "dialog"
-          def popup_id_for(panel_id) = panel_id
-          def trigger_icon = nil
-          def trigger_options = {}
-          def stimulus_data(_panel_id, _options) = {}
+          def haspopup
+            "dialog"
+          end
+
+          def popup_id_for(panel_id)
+            panel_id
+          end
+
+          def trigger_icon
+            nil
+          end
+
+          def trigger_options
+            {}
+          end
+
+          def stimulus_data(_panel_id, _options)
+            {}
+          end
         end
 
         private
@@ -38,7 +74,9 @@ module StimulusPlumbers
           nil
         end
 
-        def selection = resolve(:variant)
+        def selection
+          resolve(:variant)
+        end
       end
     end
   end

data/lib/stimulus_plumbers/components/combobox/date.rb

@@ -16,21 +16,47 @@ module StimulusPlumbers
           "#{STIMULUS_CONTROLLER}:selected->#{Components::Popover::STIMULUS_CONTROLLER}#closeOnSelect"
         ].join(" ").freeze
 
-        def self.month_id_for(panel_id)   = [panel_id, "calendar_month"].compact.join("_")
-        def self.year_id_for(panel_id)    = [panel_id, "calendar_year"].compact.join("_")
-        def self.decade_id_for(panel_id)  = [panel_id, "calendar_decade"].compact.join("_")
+        class << self
+          def month_id_for(panel_id)
+            [panel_id, "calendar_month"].compact.join("_")
+          end
+
+          def year_id_for(panel_id)
+            [panel_id, "calendar_year"].compact.join("_")
+          end
+
+          def decade_id_for(panel_id)
+            [panel_id, "calendar_decade"].compact.join("_")
+          end
+        end
 
         module Metadata
           module_function
 
-          def haspopup = "dialog"
-          def popup_id_for(panel_id) = panel_id
-          def trigger_icon = "calendar"
-          def trigger_options = {}
-          def stimulus_data(_panel_id, _options) = { input_formatter_format_value: "date" }
+          def haspopup
+            "dialog"
+          end
+
+          def popup_id_for(panel_id)
+            panel_id
+          end
+
+          def trigger_icon
+            "calendar"
+          end
+
+          def trigger_options
+            {}
+          end
+
+          def stimulus_data(_panel_id, _options)
+            { input_formatter_format_value: "date" }
+          end
         end
 
-        def render(...) = render_date(...)
+        def render(...)
+          render_date(...)
+        end
 
         private
 

data/lib/stimulus_plumbers/components/combobox/dropdown.rb

@@ -15,14 +15,30 @@ module StimulusPlumbers
         module Metadata
           module_function
 
-          def haspopup = "listbox"
-          def popup_id_for(panel_id) = panel_id
-          def trigger_icon = "chevron-down"
-          def trigger_options = {}
-          def stimulus_data(_panel_id, _options) = {}
+          def haspopup
+            "listbox"
+          end
+
+          def popup_id_for(panel_id)
+            panel_id
+          end
+
+          def trigger_icon
+            "chevron-down"
+          end
+
+          def trigger_options
+            {}
+          end
+
+          def stimulus_data(_panel_id, _options)
+            {}
+          end
         end
 
-        def render(...) = render_dropdown(...)
+        def render(...)
+          render_dropdown(...)
+        end
 
         private
 

data/lib/stimulus_plumbers/components/combobox/time.rb

@@ -13,10 +13,21 @@ module StimulusPlumbers
         module Metadata
           module_function
 
-          def haspopup = "dialog"
-          def popup_id_for(panel_id) = panel_id
-          def trigger_icon = "clock"
-          def trigger_options = {}
+          def haspopup
+            "dialog"
+          end
+
+          def popup_id_for(panel_id)
+            panel_id
+          end
+
+          def trigger_icon
+            "clock"
+          end
+
+          def trigger_options
+            {}
+          end
 
           def stimulus_data(_panel_id, options)
             {
@@ -26,7 +37,9 @@ module StimulusPlumbers
           end
         end
 
-        def render(...) = render_time(...)
+        def render(...)
+          render_time(...)
+        end
 
         private
 

data/lib/stimulus_plumbers/components/combobox/typeahead.rb

@@ -4,17 +4,30 @@ module StimulusPlumbers
   module Components
     class Combobox
       class Typeahead < Plumber::Base
-        def self.listbox_id_for(panel_id)
-          [panel_id, "listbox"].compact.join("_")
+        class << self
+          def listbox_id_for(panel_id)
+            [panel_id, "listbox"].compact.join("_")
+          end
         end
 
         module Metadata
           module_function
 
-          def haspopup = "listbox"
-          def popup_id_for(panel_id) = Typeahead.listbox_id_for(panel_id)
-          def trigger_icon = nil
-          def trigger_options = { readonly: false, aria: { autocomplete: "list" } }
+          def haspopup
+            "listbox"
+          end
+
+          def popup_id_for(panel_id)
+            Typeahead.listbox_id_for(panel_id)
+          end
+
+          def trigger_icon
+            nil
+          end
+
+          def trigger_options
+            { readonly: false, aria: { autocomplete: "list" } }
+          end
 
           def stimulus_data(panel_id, _options)
             {
@@ -24,7 +37,9 @@ module StimulusPlumbers
           end
         end
 
-        def render(...) = render_typeahead(...)
+        def render(...)
+          render_typeahead(...)
+        end
 
         private
 

data/lib/stimulus_plumbers/components/icon.rb

@@ -3,8 +3,10 @@
 module StimulusPlumbers
   module Components
     class Icon < Plumber::Base
-      def self.icon_name?(value)
-        value.is_a?(Symbol) || (value.is_a?(String) && !value.html_safe?)
+      class << self
+        def icon_name?(value)
+          value.is_a?(Symbol) || (value.is_a?(String) && !value.html_safe?)
+        end
       end
 
       def render(name:, size: :lg, **kwargs)

data/lib/stimulus_plumbers/components/indicator.rb

@@ -3,7 +3,9 @@
 module StimulusPlumbers
   module Components
     class Indicator < Plumber::Base
-      def render(...) = render_indicator(...)
+      def render(...)
+        render_indicator(...)
+      end
 
       private
 

data/lib/stimulus_plumbers/components/popover.rb

@@ -5,11 +5,15 @@ module StimulusPlumbers
     class Popover < Plumber::Base
       STIMULUS_CONTROLLER = "popover"
 
-      def self.panel_id_for(trigger_id)
-        [trigger_id, "popover"].compact.join("_")
+      class << self
+        def panel_id_for(trigger_id)
+          [trigger_id, "popover"].compact.join("_")
+        end
       end
 
-      def render(...) = render_popover(...)
+      def render(...)
+        render_popover(...)
+      end
 
       def build(panel_id: nil, &block)
         @panel_id     = panel_id || self.class.panel_id_for(template.sp_dom_id)

data/lib/stimulus_plumbers/components/progress_bar.rb

@@ -3,7 +3,9 @@
 module StimulusPlumbers
   module Components
     class ProgressBar < Plumber::Base
-      def render(...) = render_bar(...)
+      def render(...)
+        render_bar(...)
+      end
 
       private
 

data/lib/stimulus_plumbers/components/progress_meter.rb

@@ -3,7 +3,9 @@
 module StimulusPlumbers
   module Components
     class ProgressMeter < Plumber::Base
-      def render(...) = render_meter(...)
+      def render(...)
+        render_meter(...)
+      end
 
       private
 

data/lib/stimulus_plumbers/components/progress_ring.rb

@@ -3,7 +3,9 @@
 module StimulusPlumbers
   module Components
     class ProgressRing < Plumber::Base
-      def render(...) = render_ring(...)
+      def render(...)
+        render_ring(...)
+      end
 
       private
 

data/lib/stimulus_plumbers/components/timeline/event.rb

@@ -6,8 +6,10 @@ module StimulusPlumbers
       class Event < Plumber::Base
         attr_reader :interactive
 
-        def self.detail_id_for(event_id)
-          [event_id, "detail"].compact.join("_")
+        class << self
+          def detail_id_for(event_id)
+            [event_id, "detail"].compact.join("_")
+          end
         end
 
         def render(datetime: nil, id: nil, interactive: false, orientation: :vertical, **kwargs, &block)

data/lib/stimulus_plumbers/form/field.rb

@@ -15,8 +15,10 @@ module StimulusPlumbers
 
       attr_reader :hide_label
 
-      def self.label_id(input_id)
-        [input_id, "label"].compact.join("_")
+      class << self
+        def label_id(input_id)
+          [input_id, "label"].compact.join("_")
+        end
       end
 
       def initialize(template, hide_label: false, **kwargs)

data/lib/stimulus_plumbers/form/fields/inputs/code.rb

@@ -5,64 +5,124 @@ module StimulusPlumbers
     module Fields
       module Inputs
         module Code
+          STIMULUS_CONTROLLER  = "input-formatter"
+          STIMULUS_ACTION      = [
+            "input->#{STIMULUS_CONTROLLER}#onInput",
+            "focus->#{STIMULUS_CONTROLLER}#onFocus",
+            "blur->#{STIMULUS_CONTROLLER}#onBlur"
+          ].join(" ").freeze
+          DEFAULT_CHARSET      = :digits
+          DEFAULT_AUTOCOMPLETE = "one-time-code"
+          DEFAULT_SEPARATOR    = nil
+
           private
 
-          def render_code_input(attribute, html_opts, opts, error, length:, charset: :digits, groups: [], **kwargs)
-            floating = kwargs.delete(:floating)
+          def render_code_input(
+            attribute,
+            html_opts,
+            opts,
+            error,
+            length: nil,
+            charset: DEFAULT_CHARSET,
+            groups: [],
+            separator: DEFAULT_SEPARATOR,
+            floating: nil,
+            **kwargs
+          )
             raise ArgumentError, "floating labels are not supported for code fields" if floating.present?
 
             validate_code_options!(length, groups)
-            inputmode = kwargs.delete(:inputmode) || (charset.to_sym == :digits ? "numeric" : nil)
-            autocomplete = kwargs.delete(:autocomplete) || "one-time-code"
-            config = { error: error, length: length, charset: charset, groups: groups,
-                       autocomplete: autocomplete, inputmode: inputmode, kwargs: kwargs
-}
+            config = {
+              error:        error,
+              length:       length,
+              charset:      charset,
+              groups:       groups,
+              separator:    separator,
+              autocomplete: kwargs.delete(:autocomplete) || DEFAULT_AUTOCOMPLETE,
+              inputmode:    kwargs.delete(:inputmode) || (charset.to_sym == DEFAULT_CHARSET ? "numeric" : nil),
+              kwargs:       kwargs
+            }
             render_code_field(attribute, html_opts, opts, config)
           end
 
           def render_code_field(attribute, html_opts, opts, config)
-            @template.content_tag(:div, **code_wrapper_options(config)) do
+            overlay_options = merge_html_options(
+              theme.resolve(:form_field_input_code_overlay, error: config[:error]),
+              opts,
+              html_opts
+            )
+            wrapper_options = merge_html_options(
+              theme.resolve(:form_field_input_code, error: config[:error]),
+              code_options(config)
+            )
+            @template.content_tag(:div, **wrapper_options) do
               @template.safe_join(
-                [render_code_cells(config), code_input(attribute, html_opts, opts, config)]
+                [render_code_cells(config), code_input(attribute, overlay_options, config)]
               )
             end
           end
 
-          def code_wrapper_options(config)
-            merge_html_options(
-              theme.resolve(:form_field_input_code, error: config[:error]),
-              { data: {
-                controller:                    "input-formatter",
+          def code_options(config)
+            {
+              data: {
+                controller:                    STIMULUS_CONTROLLER,
                 input_formatter_format_value:  "code",
-                input_formatter_options_value: { charset: config[:charset].to_s, length: config[:length] }.to_json,
-                input_formatter_groups_value:  config[:groups].presence
+                input_formatter_options_value: { charset: config[:charset].to_s, length: config[:length] },
+                input_formatter_groups_value:  code_groups_value(config)
               }
-}
-            )
+            }
+          end
+
+          # Server-rendered separators already mark the group breaks. Passing groups as well
+          # would stamp data-group-end and lay the themed gap on top of the separator.
+          def code_groups_value(config)
+            return if config[:separator].present?
+
+            config[:groups].presence
           end
 
-          def code_input(attribute, html_opts, opts, config)
+          def code_input(attribute, html_opts, config)
             input_options = merge_html_options(
-              theme.resolve(:form_field_input_code_overlay, error: config[:error]),
-              opts,
               html_opts,
               config[:kwargs],
-              { maxlength: config[:length], autocomplete: config[:autocomplete], inputmode: config[:inputmode],
-                data: { input_formatter_target: "input", action: formatter_actions }
-}
+              {
+                maxlength:    config[:length],
+                autocomplete: config[:autocomplete],
+                inputmode:    config[:inputmode],
+                data:         { input_formatter_target: "input", action: STIMULUS_ACTION }
+              }
             )
             @template.text_field(@object_name, attribute, objectify_options(input_options))
           end
 
           def render_code_cells(config)
-            count = config[:groups].present? ? config[:groups].sum : config[:length]
+            @template.content_tag(:div, **merge_html_options(theme.resolve(:form_field_input_code_cells))) do
+              @template.safe_join(code_cells(config))
+            end
+          end
+
+          def code_cells(config)
+            groups = config[:groups].presence || [config[:length]]
+            groups.flat_map.with_index do |width, index|
+              cells = Array.new(width) { render_code_cell(config) }
+              index.zero? || config[:separator].blank? ? cells : [render_code_separator(config), *cells]
+            end
+          end
+
+          def render_code_cell(config)
             cell_options = merge_html_options(
               theme.resolve(:form_field_input_code_cell, error: config[:error]),
               { data: { input_formatter_target: "cell" } }
             )
-            @template.content_tag(:div, **merge_html_options(theme.resolve(:form_field_input_code_cells))) do
-              @template.safe_join(Array.new(count) { @template.content_tag(:span, nil, **cell_options) })
-            end
+            @template.content_tag(:span, nil, **cell_options)
+          end
+
+          def render_code_separator(config)
+            separator_options = merge_html_options(
+              theme.resolve(:form_field_input_code_separator),
+              { aria: { hidden: true } }
+            )
+            @template.content_tag(:span, config[:separator], **separator_options)
           end
 
           def validate_code_options!(length, groups)
@@ -73,11 +133,12 @@ module StimulusPlumbers
             raise ArgumentError, "groups must add up to length" unless groups.sum == length
           end
 
-          def valid_groups?(groups) = groups.is_a?(Array) && groups.all? { |group| positive_integer?(group) }
-          def positive_integer?(value) = value.is_a?(Integer) && value.positive?
+          def valid_groups?(groups)
+            groups.is_a?(Array) && groups.all? { |group| positive_integer?(group) }
+          end
 
-          def formatter_actions
-            "input->input-formatter#onInput focus->input-formatter#onFocus blur->input-formatter#onBlur"
+          def positive_integer?(value)
+            value.is_a?(Integer) && value.positive?
           end
         end
       end

data/lib/stimulus_plumbers/form/fields/inputs/credit_card.rb

@@ -5,64 +5,96 @@ module StimulusPlumbers
     module Fields
       module Inputs
         module CreditCard
-          DEFAULT_GROUPS = [4, 4, 4, 4].freeze
+          STIMULUS_CONTROLLER  = "input-formatter"
+          STIMULUS_ACTION      = [
+            "input->#{STIMULUS_CONTROLLER}#onInput",
+            "focus->#{STIMULUS_CONTROLLER}#onFocus",
+            "blur->#{STIMULUS_CONTROLLER}#onBlur"
+          ].join(" ").freeze
+          DEFAULT_GROUPS       = [4, 4, 4, 4].freeze
+          DEFAULT_AUTOCOMPLETE = "cc-number"
+          DEFAULT_INPUTMODE    = "numeric"
+          DEFAULT_SEPARATOR    = nil
 
           private
 
-          def render_credit_card_input(attribute, html_opts, opts, error, groups: DEFAULT_GROUPS, floating: nil, **kwargs)
+          def render_credit_card_input(
+            attribute,
+            html_opts,
+            opts,
+            error,
+            groups: DEFAULT_GROUPS,
+            separator: DEFAULT_SEPARATOR,
+            floating: nil,
+            **kwargs
+          )
             raise ArgumentError, "floating labels are not supported for credit card fields" if floating.present?
 
             normalized_groups = groups.presence || DEFAULT_GROUPS
-            inputmode = kwargs.delete(:inputmode) || "numeric"
-            autocomplete = kwargs.delete(:autocomplete) || "cc-number"
             validate_credit_card_groups!(normalized_groups)
-            length = normalized_groups.sum
-            config = { error: error, groups: normalized_groups, length: length,
-                       autocomplete: autocomplete, inputmode: inputmode, kwargs: kwargs
-}
+            config = {
+              error:        error,
+              groups:       normalized_groups,
+              length:       normalized_groups.sum,
+              separator:    separator,
+              autocomplete: kwargs.delete(:autocomplete) || DEFAULT_AUTOCOMPLETE,
+              inputmode:    kwargs.delete(:inputmode) || DEFAULT_INPUTMODE,
+              kwargs:       kwargs
+            }
             render_credit_card_field(attribute, html_opts, opts, config)
           end
 
           def render_credit_card_field(attribute, html_opts, opts, config)
-            @template.content_tag(:div, **credit_card_wrapper_options(config)) do
+            overlay_options = merge_html_options(
+              theme.resolve(:form_field_input_credit_card_overlay, error: config[:error]),
+              opts,
+              html_opts
+            )
+            wrapper_options = merge_html_options(
+              theme.resolve(:form_field_input_credit_card, error: config[:error]),
+              credit_card_options(config)
+            )
+            @template.content_tag(:div, **wrapper_options) do
               @template.safe_join(
-                [render_credit_card_cells(config), credit_card_input(attribute, html_opts, opts, config)]
+                [render_credit_card_cells(config), credit_card_input(attribute, overlay_options, config)]
               )
             end
           end
 
-          def credit_card_wrapper_options(config)
-            merge_html_options(
-              theme.resolve(:form_field_input_credit_card, error: config[:error]),
-              { data: {
-                controller:                   "input-formatter",
+          def credit_card_options(config)
+            {
+              data: {
+                controller:                   STIMULUS_CONTROLLER,
                 input_formatter_format_value: "creditCard",
                 input_formatter_groups_value: config[:groups]
               }
-}
-            )
+            }
           end
 
-          def credit_card_input(attribute, html_opts, opts, config)
+          def credit_card_input(attribute, html_opts, config)
             input_options = merge_html_options(
-              theme.resolve(:form_field_input_credit_card_overlay, error: config[:error]),
-              opts,
               html_opts,
               config[:kwargs],
-              { maxlength: config[:length], autocomplete: config[:autocomplete], inputmode: config[:inputmode],
-                data: { input_formatter_target: "input", action: formatter_actions }
-}
+              {
+                maxlength:    config[:length],
+                autocomplete: config[:autocomplete],
+                inputmode:    config[:inputmode],
+                data:         { input_formatter_target: "input", action: STIMULUS_ACTION }
+              }
             )
             @template.text_field(@object_name, attribute, objectify_options(input_options))
           end
 
           def render_credit_card_cells(config)
-            cells = config[:groups].each_index.flat_map do |index|
-              index.zero? ? [render_credit_card_cell(config)] : [render_credit_card_separator, render_credit_card_cell(config)]
+            @template.content_tag(:div, **merge_html_options(theme.resolve(:form_field_input_credit_card_cells))) do
+              @template.safe_join(credit_card_cells(config))
             end
+          end
 
-            @template.content_tag(:div, **merge_html_options(theme.resolve(:form_field_input_credit_card_cells))) do
-              @template.safe_join(cells)
+          def credit_card_cells(config)
+            config[:groups].each_index.flat_map do |index|
+              cell = render_credit_card_cell(config)
+              index.zero? || config[:separator].blank? ? [cell] : [render_credit_card_separator(config), cell]
             end
           end
 
@@ -74,12 +106,12 @@ module StimulusPlumbers
             @template.content_tag(:span, nil, **cell_options)
           end
 
-          def render_credit_card_separator
+          def render_credit_card_separator(config)
             separator_options = merge_html_options(
               theme.resolve(:form_field_input_credit_card_separator),
               { aria: { hidden: true } }
             )
-            @template.content_tag(:span, "-", **separator_options)
+            @template.content_tag(:span, config[:separator], **separator_options)
           end
 
           def validate_credit_card_groups!(groups)
@@ -87,10 +119,6 @@ module StimulusPlumbers
 
             raise ArgumentError, "groups must be an array of positive integers"
           end
-
-          def formatter_actions
-            "input->input-formatter#onInput focus->input-formatter#onFocus blur->input-formatter#onBlur"
-          end
         end
       end
     end

data/lib/stimulus_plumbers/form/fields/inputs/password.rb

@@ -5,6 +5,9 @@ module StimulusPlumbers
     module Fields
       module Inputs
         module Password
+          STIMULUS_CONTROLLER = "input-formatter"
+          STIMULUS_ACTION     = "click->#{STIMULUS_CONTROLLER}#toggle".freeze
+
           def password_field(attribute, floating: nil, revealable: false, **options)
             html_options = merge_html_options(theme.resolve(:form_field_input, floating: floating), options)
             if revealable
@@ -42,7 +45,7 @@ module StimulusPlumbers
               trailing: method(:reveal_button),
               **merge_html_options(
                 theme.resolve(:form_field_input_reveal, error: error),
-                { data: { controller: "input-formatter", input_formatter_format_value: "password" } }
+                { data: { controller: STIMULUS_CONTROLLER, input_formatter_format_value: "password" } }
               )
             ) { @template.capture(&block) }
           end
@@ -66,7 +69,7 @@ module StimulusPlumbers
                 {
                   type: "button",
                   aria: { label: I18n.t("stimulus_plumbers.form.password.show", default: "Show password"), pressed: "false" },
-                  data: { input_formatter_target: "toggle", action: "click->input-formatter#toggle" }
+                  data: { input_formatter_target: "toggle", action: STIMULUS_ACTION }
                 }
               )
             ) { @template.capture(&block) }

data/lib/stimulus_plumbers/form/fields/inputs/submit.rb

@@ -5,22 +5,67 @@ module StimulusPlumbers
     module Fields
       module Inputs
         module Submit
+          include Components::Button::IconLayout
+
           def submit(value = nil, options = {})
-            if value.is_a?(Hash)
-              options = value
-              value = nil
-            end
+            value, options = normalize_submit_arguments(value, options)
             value ||= submit_default_value
-            type    = options.delete(:type)    { :default }
-            variant = options.delete(:variant) { :primary }
+            submit_options = extract_submit_options(options)
+
+            validate_submit_accessible_name!(value, options)
+
+            render_submit_button(value, options, **submit_options)
+          end
+
+          private
+
+          def normalize_submit_arguments(value, options)
+            value.is_a?(Hash) ? [nil, value] : [value, options]
+          end
+
+          def extract_submit_options(options)
+            {
+              type:          options.delete(:type) { :default },
+              variant:       options.delete(:variant) { :primary },
+              icon_leading:  options.delete(:icon_leading),
+              icon_trailing: options.delete(:icon_trailing),
+              hide_label:    options.delete(:hide_label) { false }
+            }
+          end
 
+          def render_submit_button(value, options, type:, variant:, icon_leading:, icon_trailing:, hide_label:)
             Components::Button.new(@template).build(type: type, variant: variant) do |attrs|
               @template.tag.button(
                 type: "submit",
                 **merge_html_options(attrs, theme.resolve(:form_submit, type: type, variant: variant), options)
-              ) { @template.content_tag(:span, value) }
+              ) { build_layout(submit_slots(icon_leading, icon_trailing)) { submit_label(value, hide_label) } }
             end
           end
+
+          def submit_slots(icon_leading, icon_trailing)
+            Components::Button::Slots.new(@template).tap do |slots|
+              slots.with_icon_leading(icon_leading) if icon_leading
+              slots.with_icon_trailing(icon_trailing) if icon_trailing
+            end
+          end
+
+          def submit_label(value, hide_label)
+            @template.content_tag(
+              :span,
+              value,
+              **merge_html_options(
+                theme.resolve(:form_submit_label, hidden: hide_label),
+                (hide_label ? { data: { sp_label_hidden: true } } : {})
+              )
+            )
+          end
+
+          def validate_submit_accessible_name!(value, options)
+            return if value.present? || options.dig(:aria, :label).present? ||
+                      options.dig(:aria, :labelledby).present? || options[:"aria-label"].present?
+
+            raise ArgumentError, "submit button has no accessible name: pass a value or aria: { label: ... }"
+          end
         end
       end
     end

data/lib/stimulus_plumbers/generators/css_entrypoint.rb

@@ -74,6 +74,7 @@ module StimulusPlumbers
 
         entry = "/#{relative_to_destination(path)}"
         return if File.readlines(gitignore, chomp: true).include?(entry)
+        return if git_ignores?(path)
 
         File.open(gitignore, "a") { |file| file.puts(entry) }
         say_status :append, ".gitignore", :green
@@ -81,6 +82,15 @@ module StimulusPlumbers
         say "Could not update .gitignore: #{e.message}. Skipping.", :yellow
       end
 
+      def git_ignores?(path)
+        Dir.chdir(destination_root) do
+          system("git", "check-ignore", "-q", relative_to_destination(path), out: File::NULL, err: File::NULL)
+        end
+      rescue StandardError => e
+        say "Could not check .gitignore coverage with git: #{e.message}. Proceeding to append.", :yellow
+        false
+      end
+
       # CSS copied by an installer belongs to the application from this point on.
       # Keep an existing file intact so a generator rerun never overwrites local
       # customizations (the same policy used by tailwindcss-rails' installer).

data/lib/stimulus_plumbers/plumber/dispatcher.rb

@@ -8,19 +8,21 @@ require_relative "dispatcher/klass_proxy"
 module StimulusPlumbers
   module Plumber
     module Dispatcher
-      def self.build(callable, *args, method_name: nil, init_args: [], init_kwargs: {}, **kwargs, &block)
-        case callable
-        when Symbol
-          MethodCall.new(callable, *args, **kwargs, &block)
-        when Proc
-          InstanceExec.new(callable, *args, **kwargs)
-        when Module
-          KlassProxy.new(callable, method_name, *args, init_args: init_args, init_kwargs: init_kwargs, **kwargs, &block)
-        when String
-          klass = callable.safe_constantize
-          raise ArgumentError, "could not resolve class from: #{callable.inspect}" unless klass
+      class << self
+        def build(callable, *args, method_name: nil, init_args: [], init_kwargs: {}, **kwargs, &block)
+          case callable
+          when Symbol
+            MethodCall.new(callable, *args, **kwargs, &block)
+          when Proc
+            InstanceExec.new(callable, *args, **kwargs)
+          when Module
+            KlassProxy.new(callable, method_name, *args, init_args: init_args, init_kwargs: init_kwargs, **kwargs, &block)
+          when String
+            klass = callable.safe_constantize
+            raise ArgumentError, "could not resolve class from: #{callable.inspect}" unless klass
 
-          KlassProxy.new(klass, method_name, *args, init_args: init_args, init_kwargs: init_kwargs, **kwargs, &block)
+            KlassProxy.new(klass, method_name, *args, init_args: init_args, init_kwargs: init_kwargs, **kwargs, &block)
+          end
         end
       end
     end

data/lib/stimulus_plumbers/plumber/slots.rb

@@ -3,14 +3,6 @@
 module StimulusPlumbers
   module Plumber
     class Slots
-      def self.slot(*names, by: nil)
-        names.each do |name|
-          by ? define_by_slot(name, by) : define_flat_slot(name)
-          define_reader(name)
-          define_predicate(name)
-        end
-      end
-
       def initialize(template = nil)
         @slots = {}
         @template = template
@@ -50,6 +42,14 @@ module StimulusPlumbers
       end
 
       class << self
+        def slot(*names, by: nil)
+          names.each do |name|
+            by ? define_by_slot(name, by) : define_flat_slot(name)
+            define_reader(name)
+            define_predicate(name)
+          end
+        end
+
         private
 
         def define_flat_slot(name)

data/lib/stimulus_plumbers/themes/schema.rb

@@ -186,6 +186,7 @@ module StimulusPlumbers
         form_field_input_code_cell:             {
           error: { default: false, validate: Ranges::BOOL }
         }.freeze,
+        form_field_input_code_separator:        {}.freeze,
         form_field_input_code_overlay:          {
           error: { default: false, validate: Ranges::BOOL }
         }.freeze,
@@ -205,6 +206,9 @@ module StimulusPlumbers
         form_submit:                            {
           type:    { default: :default, validate: Button::Ranges::TYPE },
           variant: { default: :primary, validate: Button::Ranges::VARIANT }
+        }.freeze,
+        form_submit_label:                      {
+          hidden: { default: false, validate: Ranges::BOOL }
         }.freeze
       }.freeze
 

data/lib/stimulus_plumbers/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module StimulusPlumbers
-  VERSION = "0.4.11"
+  VERSION = "0.4.12"
 end

data/lib/stimulus_plumbers.rb

@@ -19,6 +19,7 @@ require_relative "stimulus_plumbers/plumber/base"
 require_relative "stimulus_plumbers/components/icon"
 require_relative "stimulus_plumbers/components/indicator"
 require_relative "stimulus_plumbers/components/avatar"
+require_relative "stimulus_plumbers/components/button/icon_layout"
 require_relative "stimulus_plumbers/components/button"
 require_relative "stimulus_plumbers/components/button/slots"
 require_relative "stimulus_plumbers/components/button/group"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: stimulus_plumbers
 version: !ruby/object:Gem::Version
-  version: 0.4.11
+  version: 0.4.12
 platform: ruby
 authors:
 - Ryan Chang
@@ -74,6 +74,7 @@ files:
 - lib/stimulus_plumbers/components/avatar.rb
 - lib/stimulus_plumbers/components/button.rb
 - lib/stimulus_plumbers/components/button/group.rb
+- lib/stimulus_plumbers/components/button/icon_layout.rb
 - lib/stimulus_plumbers/components/button/slots.rb
 - lib/stimulus_plumbers/components/calendar.rb
 - lib/stimulus_plumbers/components/calendar/turbo.rb