stimulus_plumbers 0.4.11 → 0.4.13

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)
@@ -106,7 +108,7 @@ module StimulusPlumbers
         def render_indicator_content(type:, icon_name:)
           if type == :icon && icon_name
             Components::Icon.new(template).render(
-              name:    icon_name,
+              icon_name,
               size:    :sm,
               classes: theme.resolve(:timeline_item_indicator_icon_slot).fetch(:classes, ""),
               aria:    { hidden: "true" }

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,11 +5,19 @@ module StimulusPlumbers
     module Fields
       module Inputs
         module Password
+          STIMULUS_CONTROLLER = "input-revealable"
+          STIMULUS_ACTION     = "click->#{STIMULUS_CONTROLLER}#toggle".freeze
+          DEFAULT_AUTOCOMPLETE = "current-password"
+
           def password_field(attribute, floating: nil, revealable: false, **options)
-            html_options = merge_html_options(theme.resolve(:form_field_input, floating: floating), options)
+            html_options = merge_html_options(
+              theme.resolve(:form_field_input, floating: floating),
+              options,
+              { autocomplete: options.delete(:autocomplete) || DEFAULT_AUTOCOMPLETE }
+            )
             if revealable
               render_revealable_password(false) do
-                super(attribute, merge_html_options(html_options, { data: { input_formatter_target: "input" } }))
+                super(attribute, merge_html_options(html_options, { data: { input_revealable_target: "input" } }))
               end
             else
               super(attribute, html_options)
@@ -23,11 +31,12 @@ module StimulusPlumbers
               theme.resolve(:form_field_input, floating: floating, error: error),
               opts,
               html_opts,
-              kwargs
+              kwargs,
+              { autocomplete: kwargs.delete(:autocomplete) || DEFAULT_AUTOCOMPLETE }
             )
             if revealable
               render_revealable_password(error, floating: floating) do
-                revealable_html_options = merge_html_options(html_options, { data: { input_formatter_target: "input" } })
+                revealable_html_options = merge_html_options(html_options, { data: { input_revealable_target: "input" } })
                 @template.password_field(@object_name, attribute, objectify_options(revealable_html_options))
               end
             else
@@ -42,22 +51,38 @@ 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: reveal_data
               )
             ) { @template.capture(&block) }
           end
 
           def reveal_button
             build_reveal_button do
-              Components::Icon.new(@template).render(
-                name: "reveal",
-                size: :sm,
-                aria: { hidden: "true" },
-                **theme.resolve(:button_icon)
+              @template.safe_join(
+                [password_icon("reveal", "revealIcon"), password_icon("conceal", "concealIcon", hidden: true)]
               )
             end
           end
 
+          def reveal_data
+            {
+              controller:                           STIMULUS_CONTROLLER,
+              input_revealable_reveal_label_value:  I18n.t("stimulus_plumbers.form.password.show", default: "Show password"),
+              input_revealable_conceal_label_value: I18n.t("stimulus_plumbers.form.password.hide", default: "Hide password")
+            }
+          end
+
+          def password_icon(name, target, hidden: false)
+            Components::Icon.new(@template).render(
+              name,
+              size:   :sm,
+              aria:   { hidden: "true" },
+              data:   { input_revealable_target: target },
+              hidden: hidden,
+              **theme.resolve(:button_icon)
+            )
+          end
+
           def build_reveal_button(&block)
             @template.content_tag(
               :button,
@@ -65,8 +90,8 @@ module StimulusPlumbers
                 theme.resolve(:form_field_input_button_reveal),
                 {
                   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" }
+                  aria: { label: I18n.t("stimulus_plumbers.form.password.show", default: "Show password") },
+                  data: { input_revealable_target: "toggle", action: STIMULUS_ACTION }
                 }
               )
             ) { @template.capture(&block) }

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

@@ -82,7 +82,7 @@ module StimulusPlumbers
           def clear_button
             build_clear_button do
               Components::Icon.new(@template).render(
-                name: "close",
+                "close",
                 size: :sm,
                 aria: { hidden: "true" },
                 **theme.resolve(:button_icon)

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/helpers/icon_helper.rb

@@ -3,8 +3,8 @@
 module StimulusPlumbers
   module Helpers
     module IconHelper
-      def sp_icon(name:, **kwargs)
-        Components::Icon.new(self).render(name: name, **kwargs)
+      def sp_icon(name, **kwargs)
+        Components::Icon.new(self).render(name, **kwargs)
       end
     end
   end

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.13"
 end