satis 2.1.5 → 2.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ab24a057287e49bf11f24ca8f304df57020c3904a79160fa8b4a625e55380d5a
-  data.tar.gz: bdd35c925b3c002640195b642cd652719f24931b27fe4915f528d9800b27fb24
+  metadata.gz: 3ea32c052f123438b8208bfd8fa7dccfa23f09021f9c7033c5432663dbf719e1
+  data.tar.gz: 73a82438192349081cc304038a73db04cb3b1a1fb503b5170e27c4e9c5568369
 SHA512:
-  metadata.gz: db13c90b7bf3e47ada1d6ee10d386c6bb135a183b4bb0f365f12fc42205dd25000e9da2210e8c5ea5e6245aafaf877584c2bec618144e9445b9eee44d98a072f
-  data.tar.gz: 729675b75520efe3b592af046c999dda0a59a58d55f25f80647f96bc28ce4debe2499918cb3719be2e39978fab353df24dd3e249ecad73886f5a854baf1a0b3d
+  metadata.gz: 1521ccc6f5a19ac00f532b04ee1e794ba051e956bc95c9ca39b96919f81455130101e69fd09eb452fd51dbcc313041266da24abac4321955cc9b188303dd6e0e
+  data.tar.gz: b4d56886421bcd276828a103bf1611ebe4d3812aa997d5cac043303187cfd8d6846c5e24022f7d8330fb4f6e1e4a13a0975710dcc2ac0ffb510aabf41d174bc8

data/app/components/satis/dropdown/component_controller.js

@@ -615,6 +615,32 @@ export default class DropdownComponentController extends ApplicationController {
             this.selectItem(dataDiv)
             this.setSelectedItem(dataDiv.getAttribute("data-satis-dropdown-item-value"))
             this.searchQueryValue = ""
+          } else if(this.searchQueryValue?.length > 0) {
+            // hide all items that don't match the search query
+            const searchValue = this.searchQueryValue
+            let matches = []
+            this.itemTargets.forEach((item) => {
+              const text = item.getAttribute("data-satis-dropdown-item-text")
+              const matched = this.needsExactMatchValue
+                ? searchValue.localeCompare(text, undefined, { sensitivity: "base" }) === 0
+                : new RegExp(searchValue, "i").test(text)
+
+              const isHidden = item.classList.contains("hidden")
+              if (!isHidden) {
+                if (matched) {
+                  matches.push(item)
+                } else {
+                  item.classList.toggle("hidden", true)
+                }
+              }
+            })
+
+            // don't show results
+            if (matches.length > 0) {
+              this.showResultsList(event)
+            } else {
+              if (!this.showSelectedItem()) this.hideResultsList(event)
+            }
           }
 
           if (itemCount > 0) {

data/app/components/satis/sidebar_menu_item/component.css

@@ -9,6 +9,10 @@
     }
   }
 
+  &.active > [data-satis-sidebar-menu-item-target="link"] [data-satis-sidebar-menu-item-target="indicator"] {
+    @apply rotate-90;
+  }
+
   &__link {
     @apply text-gray-600 dark:text-gray-300 hover:bg-gray-50 dark:hover:bg-gray-700 hover:text-gray-900 w-full flex items-center pl-2 pr-1 py-2 text-left text-sm font-medium rounded-md focus:outline-none focus:ring-2 focus:ring-primary-500
   }

data/app/components/satis/sidebar_menu_item/component_controller.js

@@ -1,87 +1,118 @@
 import ApplicationController from "satis/controllers/application_controller"
-import { debounce } from "satis/utils"
+import {debounce} from "satis/utils"
 
 export default class SidebarMenuItemComponentController extends ApplicationController {
   static targets = ["link", "indicator", "submenu"]
 
   connect() {
     super.connect()
-
-    // Primitive, yes
-    Array.from(this.element.querySelectorAll('[data-satis-sidebar-menu-item-target="link"]')).forEach((el) => {
-      if (el.href.length > 0 && window.location.href.indexOf(el.href) >= 0) {
-        let sidebar = el.closest("nav.sidebar")
-        if(sidebar.querySelectorAll('.active').length > 0){
-          sidebar.querySelectorAll('.active').forEach((ele) => {
-            ele.classList.remove("active")
-            ele.classList.remove("focus")
-          })
-        }
-        el.classList.add("active")
-      }
-    })
-
-    if (this.isActive) {
-      this.linkTarget.classList.add("active")
-
-      if (this.hasSubmenuTarget) {
-        this.submenuTarget.classList.remove("hidden")
-        if(!this.submenuTarget.classList.contains("hidden") && !this.indicatorTarget.hasAttribute("data-fa-transform")){
-          this.indicatorTarget.setAttribute("data-fa-transform", "rotate-90")
-        }
-        if (this.linkTarget){
-          this.linkTarget.classList.add("focus")
-        }
-      } else {
-        this.linkTarget.classList.add("focus")
+    if (this.hasSubmenuTarget) {
+      const active = this.isActive
+      if (active) {
+        this.showSubmenu()
       }
     }
+
+    this.boundUpdateFocus = this.updateFocus.bind(this)
+    this.boundOpenListener = this.openListener.bind(this)
+
+    this.updateFocus(true)
+    this.element.addEventListener('sts-sidebar-menu-item:open', this.boundOpenListener)
+    window.addEventListener('popstate', debounce(this.boundUpdateFocus, 200))
+  }
+
+  disconnect() {
+    super.disconnect()
+    this.element.removeEventListener('sts-sidebar-menu-item:open', this.boundOpenListener)
+    window.removeEventListener('popstate', debounce(this.boundUpdateFocus, 200))
   }
 
   open(event) {
-    if (!this.isActive && this.hasSubmenuTarget) {
-      if (this.hasSubmenuTarget) {
-        this.submenuTarget.classList.remove("hidden")
-        this.indicatorTarget.setAttribute("data-fa-transform", "rotate-90")
+    if (this.hasSubmenuTarget) {
+      const sidebar = this.element.closest('nav.sidebar')
+      sidebar.dispatchEvent(new CustomEvent('sts-sidebar-menu-item:open', { detail: { element: this.element } }))
+
+      if (!this.isSubmenuVisible) {
+        this.showSubmenu()
+        event.preventDefault()
+      } else {
+        this.hideSubmenu()
+      }
+
+      if (this.linkTarget.classList.contains("focus")) {
+        event.preventDefault()
+      } else {
+        this.linkTarget.classList.toggle("focus", true)
       }
-      event.preventDefault()
     }
-    else {
-        if(this.linkInUrl || (this.linkTarget.href.length <= 0 && !this.hasActiveLinks)){
-          if (this.hasSubmenuTarget){
-            this.submenuTarget.classList.toggle("hidden")
-            if(!this.submenuTarget.classList.contains("hidden") && !this.indicatorTarget.hasAttribute("data-fa-transform")){
-              this.indicatorTarget.setAttribute("data-fa-transform", "rotate-90")
-            } else{
-              this.indicatorTarget.removeAttribute("data-fa-transform", "rotate-90")
-            }
-            event.preventDefault()
-
-          }
-        }
+  }
+
+  openListener(event) {
+    if (event.detail.element !== this.element && !this.element.contains(event.detail.element)) {
+      this.hideSubmenu()
+      this.linkTarget.classList.toggle("focus", false)
     }
   }
 
-  get linkInUrl() {
-    return this.linkTarget.href.length > 0 && window.location.href.indexOf(this.linkTarget.href) >= 0
+  // This method is used to show the submenu
+  showSubmenu() {
+    if (!this.hasSubmenuTarget || this.isSubmenuVisible) return
+
+    this.submenuTarget.classList.toggle("hidden", false)
+    this.element.classList.toggle("active", true)
+  }
+
+  // This method is used to hide the submenu
+  hideSubmenu() {
+    if (!this.hasSubmenuTarget || !this.isSubmenuVisible) return
+
+    this.submenuTarget.classList.toggle("hidden", true)
+    this.element.classList.toggle("active", false)
+  }
+
+  updateFocus(scroll = false) {
+    if (!this.hasLinkTarget) return
+    const focusedItem =  this.element.closest('nav.sidebar').querySelector('a.focus')
+    const linkInUrl = this.linkInUrl()
+    if (linkInUrl && (!focusedItem || linkInUrl > this.linkInUrl(focusedItem))) {
+      focusedItem?.classList.toggle("focus", false)
+      this.linkTarget.classList.toggle("focus", true)
+      if (scroll) this.linkTarget.scrollIntoView({ behavior: 'instant', block: 'nearest' })
+    } else
+      this.linkTarget.classList.toggle("focus", false)
+  }
+
+  linkInUrl(target = this.linkTarget) {
+    if(!target || target.href.length === 0  || target.pathname !== window.location.pathname || target.origin !== window.location.origin)
+      return 0
+
+    let c = 1;
+    if(target.hash === window.location.hash) c++
+    window.location.search.split('&').forEach((param) => {if (target.search.includes(param)) c+=2})
+    return c
   }
 
   get isActive() {
-    return this.linkInUrl || this.hasOpenSubmenus || this.hasActiveLinks
+    return this.linkInUrl() || this.element.classList.contains("active")
+      || Array.from(this.element.querySelectorAll('a[data-satis-sidebar-menu-item-target="link"]'))
+        .some((link) => link.classList.contains("active") || this.linkInUrl(link))
+  }
+
+  get isSubmenuVisible() {
+    return !this.submenuTarget.classList.contains("hidden")
   }
 
   get hasOpenSubmenus() {
-    return Array.from(this.element.querySelectorAll('[data-satis-sidebar-menu-item-target="submenu"]')).some((el) => {
-      return !el.classList.contains("hidden")
-      // return Array.from(el.querySelectorAll('[data-satis-sidebar-menu-item-target="submenu"]')).some((el) => {
-      //   return !el.classList.contains("hidden")
-      // })
-    })
+    return this.openSubmenus.length > 0
   }
 
-  get hasActiveLinks() {
-    return Array.from(this.element.querySelectorAll('[data-satis-sidebar-menu-item-target="link"]')).some((el) => {
-      return el.classList.contains("active")
-    })
+  /**
+   * Get a list of all open submenus
+   * @returns {NodeListOf<Element>}
+   */
+  get openSubmenus() {
+    // scope to first match. check if there are any submenus that are not hidden
+    return this.element.querySelectorAll('[data-satis-sidebar-menu-item-target="submenu"]:not([class*="hidden"])')
   }
+
 }

data/lib/satis/forms/builder.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-require 'satis/concerns/contextual_translations'
-require 'satis/forms/concerns/buttons'
-require 'satis/forms/concerns/file'
-require 'satis/forms/concerns/required'
-require 'satis/forms/concerns/select'
-require 'satis/forms/concerns/options'
+require "satis/concerns/contextual_translations"
+require "satis/forms/concerns/buttons"
+require "satis/forms/concerns/file"
+require "satis/forms/concerns/required"
+require "satis/forms/concerns/select"
+require "satis/forms/concerns/options"
 
 module Satis
   module Forms
@@ -27,13 +27,13 @@ module Satis
       end
 
       # Regular input
-      def input(method, options = {}, &block)
+      def input(method, options = {}, &)
         @form_options = options
 
         options[:input_html] ||= {}
         options[:input_html][:disabled] = options.delete(:disabled)
 
-        send(input_type_for(method, options), method, options, &block)
+        send(input_type_for(method, options), method, options, &)
       end
 
       # NOTE: TDG - seems to be overwritten below
@@ -44,14 +44,14 @@ module Satis
       # end
 
       # A codemirror editor, backed by a text-area
-      def editor(method, options = {}, &block)
+      def editor(method, options = {}, &)
         @form_options = options
 
-        editor_input(method, options, &block)
+        editor_input(method, options, &)
       end
 
       # Simple-form like association
-      def association(name, options, &block)
+      def association(name, options, &)
         @form_options = options
 
         @association = name
@@ -59,10 +59,10 @@ module Satis
 
         method = reflection.join_foreign_key
 
-        send(input_type_for(method, options), method, options, &block)
+        send(input_type_for(method, options), method, options, &)
       end
 
-      alias rails_fields_for fields_for
+      alias_method :rails_fields_for, :fields_for
 
       # Wrapper around fields_for, using Satis::Forms::Builder
       # Example:
@@ -73,7 +73,7 @@ module Satis
       #       printers_form.input :name
       #     end
       #   end
-      def fields_for(*args, &block)
+      def fields_for(*args, &)
         options = args.extract_options!
         name = args.first
         template_object = args.second
@@ -88,14 +88,14 @@ module Satis
         html_options[:data] ||= {}
         html_options[:data] = flatten_hash(html_options[:data])
         html_options[:data][:controller] =
-          ['satis-fields-for'].concat(options[:html]&.[](:data)&.[](:controller).to_s.split).join(' ')
-        html_options[:class] = ['fields_for'].concat(options[:html]&.[](:class).to_s.split).join(' ')
+          ["satis-fields-for"].concat(options[:html]&.[](:data)&.[](:controller).to_s.split).join(" ")
+        html_options[:class] = ["fields_for"].concat(options[:html]&.[](:class).to_s.split).join(" ")
 
         options[:builder] ||= if self.class < ActionView::Helpers::FormBuilder
-                                self.class
-                              else
-                                Satis::Forms::Builder
-                              end
+          self.class
+        else
+          Satis::Forms::Builder
+        end
 
         # Only do the whole nested-form thing with a collection
         if show_actions
@@ -106,7 +106,7 @@ module Satis
             options: options
           }
           tag.div(**html_options) do
-            render 'shared/fields_for', view_options, &block
+            render "shared/fields_for", view_options, &block
           end
 
           # FIXME: You would want to do this:
@@ -116,13 +116,13 @@ module Satis
         else
           invalid_feedback = nil
           if @object.errors.messages[name].present?
-            invalid_feedback = tag.div(@object.errors.messages[name].join(', '),
-                                       class: 'invalid-feedback')
+            invalid_feedback = tag.div(@object.errors.messages[name].join(", "),
+              class: "invalid-feedback")
           end
           safe_join [
-                      invalid_feedback,
-                      rails_fields_for(*args, options, &block)
-                    ].compact
+            invalid_feedback,
+            rails_fields_for(*args, options, &)
+          ].compact
         end
       end
 
@@ -130,24 +130,24 @@ module Satis
         options = args.extract_options!
         form_group(*args, options) do
           safe_join [
-                      (custom_label(*args, options[:label]) unless options[:label] == false),
-                      rich_text_area(*args, options)
-                    ]
+            (custom_label(*args, options[:label]) unless options[:label] == false),
+            rich_text_area(*args, options)
+          ]
         end
       end
 
       # A switch backed by a hidden value
-      def switch(method, options = {}, &block)
+      def switch(method, options = {}, &)
         @form_options = options
 
-        switch_input(method, options, &block)
+        switch_input(method, options, &)
       end
 
       # A hidden input
-      def hidden(method, options = {}, &block)
+      def hidden(method, options = {}, &)
         @form_options = options
 
-        hidden_input(method, options, &block)
+        hidden_input(method, options, &)
       end
 
       # Non public
@@ -155,19 +155,19 @@ module Satis
       def input_type_for(method, options)
         object_type = object_type_for_method(method)
         input_type = case object_type
-                     when :date then :date_time
-                     when :datetime then :date_time
-                     when :integer then :string
-                     when :float then :string
-                     else object_type
-                     end
+        when :date then :date_time
+        when :datetime then :date_time
+        when :integer then :string
+        when :float then :string
+        else object_type
+        end
         override_input_type = if options[:as]
-                                options[:as]
-                              elsif options[:collection]
-                                :select
-                              elsif options[:url]
-                                :dropdown
-                              end
+          options[:as]
+        elsif options[:collection]
+          :select
+        elsif options[:url]
+          :dropdown
+        end
 
         "#{override_input_type || input_type}_input"
       end
@@ -175,38 +175,38 @@ module Satis
       def form_group(method, options = {}, &block)
         tag.div(class: "form-group form-group-#{method}", data: options.delete(:data)) do
           safe_join [
-                      block.call,
-                      hint_text(options[:hint]),
-                      error_text(method)
-                    ].compact
+            block.call,
+            hint_text(options[:hint]),
+            error_text(method)
+          ].compact
         end
       end
 
       def hint_text(text)
         return if text.nil?
 
-        tag.small text, class: 'form-text text-muted'
+        tag.small text, class: "form-text text-muted"
       end
 
       # FIXME: These don't work for relations or location_id, error is on location
       # When using the association helper, we need to set a @assocation variable
       # any other input should clear it
       def error_text(method)
-        return if !has_error?(method) && !has_error?(method.to_s.gsub(/_id$/, ''))
+        return if !has_error?(method) && !has_error?(method.to_s.gsub(/_id$/, ""))
 
         all_errors = @object.errors[method].dup
-        all_errors += @object.errors[method.to_s.gsub(/_id$/, '')] if method.to_s.ends_with?('_id')
+        all_errors += @object.errors[method.to_s.gsub(/_id$/, "")] if method.to_s.ends_with?("_id")
 
-        tag.div(all_errors.uniq.join('<br />').html_safe,
-                class: 'invalid-feedback')
+        tag.div(all_errors.uniq.join("<br />").html_safe,
+          class: "invalid-feedback")
       end
 
       def object_type_for_method(method)
         result = if @object.respond_to?(:type_for_attribute) && @object.has_attribute?(method)
-                   @object.type_for_attribute(method.to_s).try(:type)
-                 elsif @object.respond_to?(:column_for_attribute) && @object.has_attribute?(method)
-                   @object.column_for_attribute(method).try(:type)
-                 end
+          @object.type_for_attribute(method.to_s).try(:type)
+        elsif @object.respond_to?(:column_for_attribute) && @object.has_attribute?(method)
+          @object.column_for_attribute(method).try(:type)
+        end
         result || :string
       end
 
@@ -220,40 +220,40 @@ module Satis
         all_classes = "#{options[:class]} form-label".strip
         label(method, title, class: all_classes, data: options[:data]) do |translation|
           safe_join [
-                      tag.span(title || translation, class: required?(method) ? 'required' : ''),
-                      ' ',
-                      required(method, options),
-                      help(method, options)
-                    ]
+            tag.span(title || translation, class: required?(method) ? "required" : ""),
+            " ",
+            required(method, options),
+            help(method, options)
+          ]
         end
       end
 
       def required(method, _options = {})
         return unless required?(method)
 
-        tag.i(class: 'fas fa-hexagon-exclamation')
+        tag.i(class: "fas fa-hexagon-exclamation")
       end
 
       def help(method, options = {})
-        text = if options[:help].present?
-                 options[:help]
-               else
-                 Satis.config.default_help_text.call(@template, @object, method,
-                                                     @options[:help_scope] || options[:help_scope])
-               end
+        text = options[:help].presence || Satis.config.default_help_text.call(@template, @object, method,
+          @options[:help_scope] || options[:help_scope])
 
         return if text.blank?
 
-        tag.i(class: 'fal fa-circle-info', 'data-controller': 'help', 'data-help-content-value': text)
+        tag.i(class: "fal fa-circle-info", "data-controller": "help", "data-help-content-value": text)
       end
 
       def hidden_input(method, options = {})
         hidden_field(method, options[:input_html] || {})
       end
 
+      def password_input(method, options = {})
+        string_input(method, options.merge(as: :password))
+      end
+
       # Inputs and helpers
       def string_input(method, options = {})
-        orig_data = options.fetch(:data, {}).merge(controller: 'satis-input')
+        orig_data = options.fetch(:data, {}).merge(controller: "satis-input")
         scrollable = options.fetch(:scrollable, false)
 
         css_class = ["form-control"]
@@ -261,58 +261,58 @@ module Satis
         css_class << "noscroll" unless scrollable
 
         data = options[:input_html].fetch(:data, {})
-        data = data.merge('satis-input-target' => 'input')
+        data = data.merge("satis-input-target" => "input")
         options[:input_html] = options[:input_html].merge(data: data)
 
         form_group(method, options.merge(data: orig_data)) do
           safe_join [
-                      (custom_label(method, options[:label], options) unless options[:label] == false),
-                      string_field(method, merge_input_options({ as: options[:as], class: "#{css_class.join(' ')}" }, options[:input_html]))
-                    ]
+            (custom_label(method, options[:label], options) unless options[:label] == false),
+            string_field(method, merge_input_options({as: options[:as], class: "#{css_class.join(" ")}"}, options[:input_html]))
+          ]
         end
       end
 
       def number_input(method, options = {})
         form_group(method, options) do
           safe_join [
-                      (custom_label(method, options[:label], options) unless options[:label] == false),
-                      number_field(method,
-                                   merge_input_options({ class: "form-control #{
+            (custom_label(method, options[:label], options) unless options[:label] == false),
+            number_field(method,
+              merge_input_options({class: "form-control #{
                                      if has_error?(method)
-                                       'is-invalid'
-                                     end}" }, options[:input_html]))
-                    ]
+                                       "is-invalid"
+                                     end}"}, options[:input_html]))
+          ]
         end
       end
 
       def text_input(method, options = {})
         form_group(method, options) do
           safe_join [
-                      (custom_label(method, options[:label], options) unless options[:label] == false),
-                      text_area(method,
-                                merge_input_options({ class: "form-control #{
+            (custom_label(method, options[:label], options) unless options[:label] == false),
+            text_area(method,
+              merge_input_options({class: "form-control #{
                                   if has_error?(method)
-                                    'is-invalid'
-                                  end}" }, options[:input_html]))
-                    ]
+                                    "is-invalid"
+                                  end}"}, options[:input_html]))
+          ]
         end
       end
 
       def input_array(method, options = {})
         form_group(method, options) do
           safe_join [
-                      (custom_label(method, options[:label], options) unless options[:label] == false),
-                      render(Satis::InputArray::Component.new(form: self, attribute: method, **options))
-                    ]
+            (custom_label(method, options[:label], options) unless options[:label] == false),
+            render(Satis::InputArray::Component.new(form: self, attribute: method, **options))
+          ]
         end
       end
 
       def editor_input(method, options = {}, &block)
         form_group(method, options) do
           safe_join [
-                      (custom_label(method, options[:label], options) unless options[:label] == false),
-                      @template.render(Satis::Editor::Component.new(form: self, attribute: method, **options, &block))
-                    ]
+            (custom_label(method, options[:label], options) unless options[:label] == false),
+            @template.render(Satis::Editor::Component.new(form: self, attribute: method, **options, &block))
+          ]
         end
         # form_group(method, options) do
         #   safe_join [
@@ -343,11 +343,11 @@ module Satis
 
       def boolean_input(method, options = {})
         form_group(method, options) do
-          tag.div(class: 'custom-control custom-checkbox') do
+          tag.div(class: "custom-control custom-checkbox") do
             safe_join [
-                        check_box(method, merge_input_options({ class: 'custom-control-input' }, options[:input_html])),
-                        label(method, options[:label], class: 'custom-control-label')
-                      ]
+              check_box(method, merge_input_options({class: "custom-control-input"}, options[:input_html])),
+              label(method, options[:label], class: "custom-control-label")
+            ]
           end
         end
       end
@@ -357,7 +357,7 @@ module Satis
       def switch_input(method, options = {}, &block)
         form_group(method, options) do
           render(Satis::Switch::Component.new(form: self, attribute: method, title: options[:label], **options,
-                                              &block))
+            &block))
         end
       end
 
@@ -371,10 +371,10 @@ module Satis
         end
         form_group(method, options) do
           safe_join [
-                      (custom_label(method, options[:label], options) unless options[:label] == false),
-                      render(Satis::DateTimePicker::Component.new(form: self, attribute: method, title: options[:label], **options,
-                                                                  &block))
-                    ]
+            (custom_label(method, options[:label], options) unless options[:label] == false),
+            render(Satis::DateTimePicker::Component.new(form: self, attribute: method, title: options[:label], **options,
+              &block))
+          ]
         end
       end
 
@@ -385,43 +385,43 @@ module Satis
         #                          'data-phone-number-target': 'input',
         #                          'data-action': 'keyup->phone-number#change blur->phone-number#change' }
 
-        tag.div('data-controller' => 'phone-number') do
+        tag.div("data-controller" => "phone-number") do
           safe_join [
-                      hidden_field(method,
-                                   merge_input_options({ class: 'form-control', 'data-phone-number-target': 'hiddenInput' },
-                                                       options[:input_html])),
-                      @template.text_field_tag('dummy', @object.try(method), class: "form-control #{
+            hidden_field(method,
+              merge_input_options({class: "form-control", "data-phone-number-target": "hiddenInput"},
+                options[:input_html])),
+            @template.text_field_tag("dummy", @object.try(method), class: "form-control #{
                         if has_error?(method)
-                          'is-invalid'
-                        end}", 'data-phone-number-target': 'input',
-                                               'data-action': 'input->phone-number#change')
-                    ]
+                          "is-invalid"
+                        end}", "data-phone-number-target": "input",
+              "data-action": "input->phone-number#change")
+          ]
         end
       end
 
       def collection_of(input_type, method, options = {})
         form_builder_method, custom_class, input_builder_method = case input_type
-                                                                  when :radio_buttons then [:collection_radio_buttons,
-                                                                                            'custom-radio', :radio_button]
-                                                                  when :check_boxes then [:collection_check_boxes,
-                                                                                          'custom-checkbox', :check_box]
-                                                                  else raise 'Invalid input_type for collection_of, valid input_types are ":radio_buttons", ":check_boxes"'
-                                                                  end
+        when :radio_buttons then [:collection_radio_buttons,
+          "custom-radio", :radio_button]
+        when :check_boxes then [:collection_check_boxes,
+          "custom-checkbox", :check_box]
+        else raise 'Invalid input_type for collection_of, valid input_types are ":radio_buttons", ":check_boxes"'
+        end
         options[:value_method] ||= :last
         options[:text_method] ||= options[:label_method] || :first
         form_group(method, options) do
           safe_join [
-                      (custom_label(method, options[:label], options) unless options[:label] == false),
-                      (send(form_builder_method, method, options[:collection], options[:value_method],
-                            options[:text_method]) do |b|
-                        tag.div(class: "custom-control #{custom_class}") do
-                          safe_join [
-                                      b.send(input_builder_method, options.fetch(:input_html, {}).merge(class: 'custom-control-input')),
-                                      b.label(class: 'custom-control-label')
-                                    ]
-                        end
-                      end)
-                    ]
+            (custom_label(method, options[:label], options) unless options[:label] == false),
+            (send(form_builder_method, method, options[:collection], options[:value_method],
+              options[:text_method]) do |b|
+               tag.div(class: "custom-control #{custom_class}") do
+                 safe_join [
+                   b.send(input_builder_method, options.fetch(:input_html, {}).merge(class: "custom-control-input")),
+                   b.label(class: "custom-control-label")
+                 ]
+               end
+             end)
+          ]
         end
       end
 
@@ -447,9 +447,9 @@ module Satis
           when /password/ then password_field(method, options)
           # FIXME: Possibly use time_zone_select with dropdown?
           when /time_zone/ then time_zone_select(method, options.delete(:priority_zones), options,
-                                                 { class: 'custom-select form-control' })
+            {class: "custom-select form-control"})
           # FIXME: Possibly use country_select with dropdown?
-          when /country/ then country_select(method, options, class: 'custom-select form-control')
+          when /country/ then country_select(method, options, class: "custom-select form-control")
           when /email/ then email_field(method, options)
           when /phone/ then phone_input(method, options)
           when /url/ then url_field(method, options)
@@ -470,7 +470,7 @@ module Satis
         hash.each_with_object({}) do |(k, v), h|
           if v.is_a? Hash
             flatten_hash(v).map do |h_k, h_v|
-              h["#{k}_#{h_k}".to_sym] = h_v
+              h[:"#{k}_#{h_k}"] = h_v
             end
           else
             h[k] = v

data/lib/satis/version.rb

@@ -1,3 +1,3 @@
 module Satis
-  VERSION = "2.1.5"
+  VERSION = "2.1.8"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: satis
 version: !ruby/object:Gem::Version
-  version: 2.1.5
+  version: 2.1.8
 platform: ruby
 authors:
 - Tom de Grunt
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-04-07 00:00:00.000000000 Z
+date: 2024-04-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: browser