tam_select 1.1.1 → 1.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3cdee3c229caaeda5d7f572395009c1ffd03e58c1f5376c215ced0e751c35fb9
-  data.tar.gz: 9896dd22aa1dc9af3727596c1bee1d82ca6b8f1462a3e24a5177b10306853888
+  metadata.gz: e3d70fb56c9207b30cbf94fa511904507ab603cfd2823fdb57abdfb5f8975fca
+  data.tar.gz: dd4deef3509a263dd2782153f51706e0460df6190007106d2956585124e080a0
 SHA512:
-  metadata.gz: 271d3b88383037c504189080665c0c15e19a640e6f8efe0d580683d9f543a0a56ff496a667064b788fbd8a8f1ddc8f48512d755cfc10985ec043d36c042891ce
-  data.tar.gz: be82081ad386749cb1ff40f1cd48ca80417104712c417de25dccc969082f3f2edfce09a912bce53467c34e170b1a0235245caede8d53717b7fff5d3b21d8f072
+  metadata.gz: 2c9dc8c29d5680178904699e5f32e2d9506e2abae14918da3c3457bc640d7c92ce458f8439461470e11e244a4a2a477ca63d0e2b1df24a99cc7bbcc76304a743
+  data.tar.gz: 4d4cb0845691bb1b4f1b1f814eafdbd5de506c4b36f9bfe8cbdbd6ab654dfef18502fab7bc92d98d02fca3349750f94d7484f8cb54ed3cdb711aa3a677a119fd

data/README.md

@@ -1,7 +1,7 @@
-the # Tam Select
+# Tam Select
 
 [![MIT License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
-[![Gem Version](https://img.shields.io/badge/version-1.1.0-blue.svg)](https://github.com/tamiru/tam_select)
+[![Gem Version](https://img.shields.io/badge/version-1.2.3-blue.svg)](https://github.com/tamiru/tam_select)
 
 **Tam Select** is an accessible, searchable select component for Ruby on Rails, built for Simple Form, Stimulus, Turbo, and Tailwind CSS. It keeps the native `<select>` as the source of truth, so Rails form submission, validation, selected values, and browser autofill continue to work.
 
@@ -29,20 +29,53 @@ bundle install
 bin/rails generate tam_select:install
 ```
 
-The generator installs:
+The generator installs the core module, Stimulus controller, Rails helpers, and remote-search concerns:
 
 ```text
 app/javascript/tam_select/tam_select.js
 app/javascript/controllers/tam_select_controller.js
-app/inputs/tam_select_input.rb
 app/controllers/concerns/tam_select_paginatable.rb
 app/controllers/concerns/tam_select_remote.rb
 app/controllers/tam_select_remote_controller.rb
 app/helpers/tam_select_helper.rb
 ```
 
+When Simple Form is present, it also installs `app/inputs/tam_select_input.rb`. Simple Form is optional; applications without it receive a short skip message and continue with standard Rails form helpers.
+
 Commit these generated files with the Rails application. This makes customization straightforward and allows Tailwind CSS 4 to scan the component without resolving a Ruby gem directory at build time.
 
+### Rails 8 importmap
+
+The default Rails 8 importmap setup needs no manual JavaScript package installation. The generator adds this pin to `config/importmap.rb`:
+
+```ruby
+pin "tam_select", to: "tam_select/tam_select.js"
+```
+
+The generated Stimulus controller imports `TamSelect` from `"tam_select"`. Running the generator again updates an old pin when necessary and never adds a duplicate. Rails' normal `pin_all_from "app/javascript/controllers", under: "controllers"` line discovers the generated controller.
+
+### jsbundling-rails and esbuild
+
+The same generated controller works with esbuild when the bare `tam_select` import is aliased to the generated core file. Add the alias flag to the existing `build` script in `package.json`:
+
+```json
+{
+  "scripts": {
+    "build": "esbuild app/javascript/*.* --bundle --sourcemap --format=esm --outdir=app/assets/builds --public-path=/assets --alias:tam_select=./app/javascript/tam_select/tam_select.js"
+  }
+}
+```
+
+This uses the local file installed by the generator. For non-Rails bundler use, install the npm package from GitHub and import its published package name instead:
+
+```bash
+npm install github:tamiru/tam_select
+```
+
+```js
+import TamSelect from "tam-select"
+```
+
 Add the generated JavaScript to Tailwind's source detection in `app/assets/tailwind/application.css`:
 
 ```css
@@ -50,7 +83,7 @@ Add the generated JavaScript to Tailwind's source detection in `app/assets/tailw
 @source "../../javascript/tam_select/**/*.js";
 ```
 
-### Updating
+### Upgrading
 
 The Rails integration files are copied into your application, so updating the gem does not update them automatically. Commit local customizations first, then run:
 
@@ -67,12 +100,15 @@ bin/rails generate tam_select:install --force
 
 Review `git diff` afterward because `--force` overwrites application-specific customizations.
 
+Versions before this release generated a relative controller import. After upgrading, confirm the controller uses `import TamSelect from "tam_select"` and that the importmap pin or esbuild alias above is present.
+
 ## Features
 
 - Single and multiple selection
 - Local search and user-created tags
 - Remote JSON search with debouncing and incremental pagination
 - Loading, empty, and error states
+- Select2-style closed selection and open search states with clear active, selected, disabled, loading, empty, and error feedback
 - Keyboard navigation: arrows, Enter, Escape, Tab, and Backspace
 - Combobox/listbox ARIA semantics
 - Light and dark Tailwind themes
@@ -80,14 +116,6 @@ Review `git diff` afterward because `--force` overwrites application-specific cu
 - Public API and bubbling custom events
 - No jQuery, Tom Select, Select2, Preline, or Floating UI dependency
 
-## JavaScript installation
-
-For a non-Rails application, install directly from GitHub:
-
-```bash
-npm install github:tamiru/tam_select
-```
-
 ## Tailwind CSS 4
 
 Add the package source to `app/assets/tailwind/application.css` so Tailwind generates every class used by the JavaScript templates:
@@ -104,7 +132,19 @@ When the Rails generator is used, scan the generated component source:
 @source "../../javascript/tam_select/**/*.js";
 ```
 
-## Rails and Stimulus
+Tam Select includes adaptive light and dark styles for every state. It follows a `dark` class on the document or any ancestor and also sets the appropriate native `color-scheme`:
+
+```js
+document.documentElement.classList.toggle("dark")
+```
+
+For Tailwind CSS 4 class-based theming, define the variant in the application stylesheet if it is not already present:
+
+```css
+@custom-variant dark (&:where(.dark, .dark *));
+```
+
+## Standard Rails forms and Stimulus
 
 The install generator copies the Stimulus controller into your application, where Stimulus normally discovers it automatically. If controllers are registered manually:
 
@@ -130,9 +170,28 @@ Use a normal Rails select:
 
 Stimulus destroys generated markup when Turbo removes the select and recreates it on reconnection.
 
+For multiple selection, Rails must receive an array field and the native select must include `multiple: true`:
+
+```erb
+<%= form.select :skill_ids,
+      options_from_collection_for_select(Skill.order(:name), :id, :name, form.object.skill_ids),
+      {},
+      multiple: true,
+      data: {
+        controller: "tam-select",
+        tam_select_options_value: {
+          searchable: true,
+          closeAfterSelect: false,
+          placeholder: "Add skills…"
+        }.to_json
+      } %>
+```
+
+The original `<select>` remains the source of truth. This preserves form names in nested forms, submitted values, prompts, `required`, validation metadata, and native `change` events.
+
 ## Simple Form
 
-The install generator creates `app/inputs/tam_select_input.rb`. Use `as: :tam_select` with any Simple Form collection input.
+When the `simple_form` gem is installed, the generator creates `app/inputs/tam_select_input.rb`. Use `as: :tam_select` with any Simple Form collection input. The input forwards Simple Form's prompt, selected values, multiple flag, error classes, ARIA attributes, and nested builder context to the native collection select.
 
 ### Local collection
 
@@ -193,8 +252,8 @@ Options are passed under `input_html[:tam_options]`. Common options include `sea
 ```json
 {
   "items": [
-    { "value": "1", "label": "Addis Ababa" },
-    { "value": "2", "label": "Afar" }
+    { "value": "1", "label": "Hana Bekele", "detail": "Admission no. UG/1024/26", "meta": "Active", "image": "/avatars/hana.jpg" },
+    { "value": "2", "label": "Afar", "detail": "Semera", "meta": "AF" }
   ],
   "pagination": {
     "page": 1,
@@ -221,6 +280,8 @@ class RegionsController < ApplicationController
     model: Region,
     label: :name,
     value: :id,
+    detail: :description,
+    meta: :code,
     search_by: %i[name code],
     scope: -> { Region.order(:name) },
     per_page: 20
@@ -255,51 +316,45 @@ Point Simple Form to that collection action:
 
 Typing sends `GET /regions/tam_select_options.json?q=addis&page=1` and receives the standard Tam Select JSON payload.
 
-### Generic remote controller
+When `pagination.has_more` is true, scrolling near the bottom requests `next_page`. Earlier pages keep their order, duplicate values are collapsed, and a later response can update an existing item's label, metadata, image, or disabled state. A new query aborts the old request and never displays cached results from the previous query.
 
-The installer generates `TamSelectRemoteController`. Create a small subclass for each allowed remote source:
+Remote items may include optional `detail`, `meta`, and `image` fields. Tam Select renders the primary label with the detail on a second line and an optional circular image on the left. The selected value keeps the same image, label, and detail, including an initial value rendered before remote search completes. `meta` remains a badge on the right.
 
-```ruby
-# app/controllers/region_options_controller.rb
-class RegionOptionsController < TamSelectRemoteController
-  tam_select model: Region, label: :name, search_by: %i[name code]
+This works well for program and student searches. For example, return the program name as `label` and admission as `detail`:
 
-  private
-
-  # Override this method when records require authorization or tenant scoping.
-  def tam_select_scope(config)
-    current_account.regions.order(:name)
-  end
-end
+```ruby
+tam_select_remote(
+  model: Estudent::Program,
+  label: :name,
+  detail: ->(program) { program.admission.to_s },
+  search_by: %i[name],
+  scope: -> { Estudent::Program.includes(admission: %i[admission_type enrollment_type enrollment_mode]).order(:name) }
+)
 ```
 
-Expose the JSON endpoint and pass it to the input:
+For student search, add the admission number and photo URL:
 
 ```ruby
-# config/routes.rb
-get "region_options", to: "region_options#index", defaults: { format: :json }
+tam_select_remote(
+  model: Estudent::Student,
+  label: ->(student) { student.full_name },
+  detail: ->(student) { "Admission no. #{student.applicant.registration_number}" },
+  image: ->(student) { url_for(student.applicant.person.avatar) if student.applicant.person.avatar.attached? },
+  search_by: %i[id_number],
+  scope: -> { Estudent::Student.includes(applicant: { person: { avatar_attachment: :blob } }) }
+)
 ```
 
+For a local native select, provide the same values as option data attributes:
+
 ```erb
-<%= form.input :region_id,
-      as: :tam_select,
-      collection: [form.object.region].compact,
-      label_method: :name,
-      value_method: :id,
-      input_html: {
-        tam_options: {
-          remoteUrl: region_options_path(format: :json),
-          minQueryLength: 1
-        }
-      } %>
+<option value="1" data-detail="Admission no. UG/1024/26" data-meta="Active" data-image="/avatars/hana.jpg">Hana Bekele</option>
 ```
 
-Do not accept a model name from request parameters. Declaring each source in a controller subclass prevents clients from querying arbitrary application models.
-
 The browser sends requests such as:
 
 ```text
-GET /region_options.json?q=addis&page=1
+GET /regions/tam_select_options.json?q=addis&page=1
 Accept: application/json
 ```
 
@@ -307,15 +362,47 @@ Test an endpoint independently with:
 
 ```bash
 curl -H "Accept: application/json" \
-  "http://localhost:3000/region_options.json?q=addis&page=1"
+  "http://localhost:3000/regions/tam_select_options.json?q=addis&page=1"
 ```
 
 A `406 Not Acceptable` response means the route or controller rejected JSON. Keep `defaults: { format: :json }` on the route, use a `.json` URL, and ensure the controller does not restrict responses to HTML only.
 
+## Creatable values
+
+Set `creatable: true` for tag-style input. The Create action is part of the same keyboard list as normal results, so ArrowUp and ArrowDown can highlight it and Enter creates it.
+
+```erb
+<%= form.select :category_ids,
+      options_from_collection_for_select(Category.order(:name), :id, :name),
+      {},
+      multiple: true,
+      data: {
+        controller: "tam-select",
+        tam_select_options_value: {
+          creatable: true,
+          closeAfterSelect: false,
+          placeholder: "Add categories…"
+        }.to_json
+      } %>
+```
+
+Values and labels are compared with normalized, case-insensitive, accent-insensitive text before creation, preventing duplicate entries such as `Café` and `cafe`. A successful creation dispatches `tam-select:create`.
+
+## Keyboard and accessibility behavior
+
+- ArrowDown and ArrowUp open the list, move through the rendered entries, and skip disabled options.
+- Enter selects the highlighted option or activates the highlighted Create action.
+- Escape closes the list and returns focus to the combobox; Tab closes without trapping focus.
+- Backspace removes the last tag from a multiple select when the search input is empty.
+- Searchable controls use an input combobox; non-searchable controls use a focusable button combobox.
+- Rails labels, descriptions, required state, disabled state, and invalid state are mirrored from the native select.
+
 ## Core JavaScript
 
+For a generated Rails/importmap installation, use the pinned module name:
+
 ```js
-import TamSelect from "tam-select"
+import TamSelect from "tam_select"
 
 const instance = new TamSelect(document.querySelector("#student_region_id"), {
   searchable: true,
@@ -325,11 +412,15 @@ const instance = new TamSelect(document.querySelector("#student_region_id"), {
 })
 
 instance.setValue("2")
+instance.open()
+instance.close()
 instance.clear()
 instance.refresh()
 instance.destroy()
 ```
 
+When consuming the npm package directly, import from `"tam-select"` instead.
+
 ## Main options
 
 | Option | Default | Purpose |
@@ -338,6 +429,8 @@ instance.destroy()
 | `creatable` | `false` | Allows typed values to become options |
 | `clearable` | `true` | Displays the clear control |
 | `closeAfterSelect` | Single only | Keeps multiple dropdowns open |
+| `placeholder` | Native prompt or `Select…` | Closed-control placeholder |
+| `searchPlaceholder` | `Search…` | Search-input placeholder |
 | `remoteUrl` | `null` | JSON search endpoint |
 | `queryParam` | `q` | Remote search parameter |
 | `pageParam` | `page` | Remote page parameter |
@@ -345,6 +438,8 @@ instance.destroy()
 | `minQueryLength` | `0` | Characters required before requesting |
 | `valueField` | `value` | Remote item value key |
 | `labelField` | `label` | Remote item label key |
+| `imageField` | `image` | Remote item image URL key |
+| `matcher` | `null` | Optional `(item, query) => boolean` local matcher |
 | `classes` | `{}` | Overrides any Tailwind class group |
 
 ## Events
@@ -353,6 +448,8 @@ Listen on the original select. Every event bubbles:
 
 ```js
 select.addEventListener("tam-select:change", ({ detail }) => console.log(detail.value))
+select.addEventListener("tam-select:open", () => console.log("opened"))
+select.addEventListener("tam-select:close", () => console.log("closed"))
 select.addEventListener("tam-select:load", ({ detail }) => console.log(detail.items))
 select.addEventListener("tam-select:create", ({ detail }) => console.log(detail.item))
 select.addEventListener("tam-select:error", ({ detail }) => console.error(detail.error))
@@ -360,6 +457,8 @@ select.addEventListener("tam-select:error", ({ detail }) => console.error(detail
 
 Standard native `change` events are also dispatched for Rails and other controllers.
 
+The supported public methods are `open()`, `close()`, `setValue(value)`, `clear()`, `refresh()`, and `destroy()`. Read the current native-compatible selection through `instance.value`, and recover an existing instance with `TamSelect.getInstance(select)`.
+
 ## Development
 
 ```bash

data/Rakefile

@@ -2,7 +2,10 @@ require "bundler/gem_tasks"
 
 begin
   require "rake/testtask"
-  Rake::TestTask.new
+  Rake::TestTask.new do |test|
+    test.libs << "test"
+    test.pattern = "test/**/*_test.rb"
+  end
 rescue LoadError
-  # The gem has no Ruby runtime tests yet.
+  # Rake's test task is unavailable.
 end

data/lib/generators/tam_select/install_generator.rb

@@ -12,8 +12,30 @@ module TamSelect
         copy_file "lib/generators/tam_select/templates/tam_select_controller.js", "app/javascript/controllers/tam_select_controller.js"
       end
 
+      def configure_importmap
+        importmap = "config/importmap.rb"
+        unless File.exist?(destination_path(importmap))
+          say "Importmap was not detected. For jsbundling/esbuild, alias tam_select to app/javascript/tam_select/tam_select.js.", :yellow
+          return
+        end
+
+        pin = 'pin "tam_select", to: "tam_select/tam_select.js"'
+        contents = File.read(destination_path(importmap))
+        existing_pin = /^\s*pin\s+["']tam_select["'].*$/
+
+        if contents.match?(existing_pin)
+          gsub_file importmap, existing_pin, pin unless contents.match?(/^#{Regexp.escape(pin)}$/)
+        else
+          append_to_file importmap, "\n#{pin}\n"
+        end
+      end
+
       def copy_simple_form_input
-        copy_file "lib/generators/tam_select/templates/tam_select_input.rb", "app/inputs/tam_select_input.rb"
+        if simple_form_available?
+          copy_file "lib/generators/tam_select/templates/tam_select_input.rb", "app/inputs/tam_select_input.rb"
+        else
+          say "Simple Form is not installed; skipped app/inputs/tam_select_input.rb. Standard Rails form helpers remain available.", :yellow
+        end
       end
 
       def copy_controller_concern
@@ -35,6 +57,16 @@ module TamSelect
         say "If your setup uses explicit sources, add:"
         say '@source "../../javascript/tam_select/**/*.js";'
       end
+
+      private
+
+      def destination_path(relative_path)
+        File.join(destination_root, relative_path)
+      end
+
+      def simple_form_available?
+        Gem.loaded_specs.key?("simple_form")
+      end
     end
   end
 end

data/lib/generators/tam_select/templates/tam_select_controller.js

@@ -1,5 +1,5 @@
 import { Controller } from "@hotwired/stimulus"
-import TamSelect from "../tam_select/tam_select"
+import TamSelect from "tam_select"
 
 export default class extends Controller {
   static values = {

data/lib/generators/tam_select/templates/tam_select_helper.rb

@@ -1,7 +1,7 @@
 module TamSelectHelper
   def tam_select_tag(name, option_tags = nil, options: {}, html_options: {}, &block)
     data = (html_options[:data] ||= {})
-    data[:controller] = [data[:controller], "tam-select"].compact.join(" ")
+    data[:controller] = (data[:controller].to_s.split + ["tam-select"]).uniq.join(" ")
     data[:tam_select_options_value] = options.to_json
     select_tag(name, option_tags, html_options, &block)
   end

data/lib/generators/tam_select/templates/tam_select_input.rb

@@ -4,7 +4,7 @@ class TamSelectInput < SimpleForm::Inputs::CollectionSelectInput
     label_method, value_method = detect_collection_methods
     tam_options = attributes.delete(:tam_options) || {}
     data = attributes[:data] ||= {}
-    data[:controller] = [data[:controller], "tam-select"].compact.join(" ")
+    data[:controller] = (data[:controller].to_s.split + ["tam-select"]).uniq.join(" ")
     data[:tam_select_options_value] = defaults.merge(tam_options).to_json
 
     @builder.collection_select(

data/lib/generators/tam_select/templates/tam_select_paginatable.rb

@@ -3,7 +3,7 @@ module TamSelectPaginatable
 
   private
 
-  def tam_select_payload(scope, label:, value: :id, per_page: 20)
+  def tam_select_payload(scope, label:, value: :id, detail: nil, meta: nil, image: nil, per_page: 20)
     page = [params.fetch(:page, 1).to_i, 1].max
     records = scope.limit(per_page + 1).offset((page - 1) * per_page).to_a
     has_more = records.length > per_page
@@ -11,9 +11,12 @@ module TamSelectPaginatable
     {
       items: records.first(per_page).map do |record|
         {
-          value: record.public_send(value).to_s,
-          label: label.respond_to?(:call) ? label.call(record) : record.public_send(label).to_s
-        }
+          value: tam_select_record_value(record, value).to_s,
+          label: tam_select_record_value(record, label).to_s,
+          detail: detail && tam_select_record_value(record, detail).to_s,
+          meta: meta && tam_select_record_value(record, meta).to_s,
+          image: image && tam_select_record_value(record, image).to_s
+        }.compact
       end,
       pagination: {
         page: page,
@@ -22,4 +25,8 @@ module TamSelectPaginatable
       }
     }
   end
+
+  def tam_select_record_value(record, resolver)
+    resolver.respond_to?(:call) ? resolver.call(record) : record.public_send(resolver)
+  end
 end

data/lib/generators/tam_select/templates/tam_select_remote.rb

@@ -7,11 +7,14 @@ module TamSelectRemote
   end
 
   class_methods do
-    def tam_select_remote(model:, label:, value: :id, search_by: nil, scope: nil, per_page: 20)
+    def tam_select_remote(model:, label:, value: :id, detail: nil, meta: nil, image: nil, search_by: nil, scope: nil, per_page: 20)
       self.tam_select_remote_config = {
         model: model,
         label: label,
         value: value,
+        detail: detail,
+        meta: meta,
+        image: image,
         search_by: Array(search_by || label),
         scope: scope,
         per_page: per_page
@@ -27,6 +30,9 @@ module TamSelectRemote
       records,
       label: config[:label],
       value: config[:value],
+      detail: config[:detail],
+      meta: config[:meta],
+      image: config[:image],
       per_page: config[:per_page]
     )
   end

data/lib/tam_select/version.rb

@@ -1,3 +1,3 @@
 module TamSelect
-  VERSION = "1.1.1"
+  VERSION = "1.2.3"
 end

data/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "tam-select",
+  "version": "1.2.3",
+  "description": "Accessible, searchable select component for Ruby on Rails, Simple Form, Stimulus, Turbo, and Tailwind CSS",
+  "homepage": "https://github.com/tamiru/tam_select",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/tamiru/tam_select.git"
+  },
+  "type": "module",
+  "main": "./src/tam-select.js",
+  "exports": {
+    ".": "./src/tam-select.js",
+    "./rails-controller": "./rails/app/javascript/controllers/tam_select_controller.js"
+  },
+  "files": [
+    "src",
+    "rails",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "test": "node --test test/*.test.js",
+    "check": "node --check src/tam-select.js && node --check rails/app/javascript/controllers/tam_select_controller.js"
+  },
+  "keywords": [
+    "select",
+    "tailwindcss",
+    "stimulus",
+    "turbo",
+    "rails",
+    "combobox"
+  ],
+  "license": "MIT",
+  "peerDependencies": {
+    "@hotwired/stimulus": ">=3.2.0"
+  },
+  "peerDependenciesMeta": {
+    "@hotwired/stimulus": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@hotwired/stimulus": "^3.2.2",
+    "esbuild": "^0.28.1",
+    "jsdom": "^29.1.1"
+  }
+}

data/rails/app/controllers/concerns/tam_select_paginatable.rb

@@ -0,0 +1,32 @@
+module TamSelectPaginatable
+  extend ActiveSupport::Concern
+
+  private
+
+  def tam_select_payload(scope, label:, value: :id, detail: nil, meta: nil, image: nil, per_page: 20)
+    page = [params.fetch(:page, 1).to_i, 1].max
+    records = scope.limit(per_page + 1).offset((page - 1) * per_page).to_a
+    has_more = records.length > per_page
+
+    {
+      items: records.first(per_page).map do |record|
+        {
+          value: tam_select_record_value(record, value).to_s,
+          label: tam_select_record_value(record, label).to_s,
+          detail: detail && tam_select_record_value(record, detail).to_s,
+          meta: meta && tam_select_record_value(record, meta).to_s,
+          image: image && tam_select_record_value(record, image).to_s
+        }.compact
+      end,
+      pagination: {
+        page: page,
+        next_page: has_more ? page + 1 : nil,
+        has_more: has_more
+      }
+    }
+  end
+
+  def tam_select_record_value(record, resolver)
+    resolver.respond_to?(:call) ? resolver.call(record) : record.public_send(resolver)
+  end
+end

data/rails/app/helpers/tam_select_helper.rb

@@ -0,0 +1,17 @@
+module TamSelectHelper
+  def tam_select_tag(name, option_tags = nil, options: {}, html_options: {}, &block)
+    data = (html_options[:data] ||= {})
+    data[:controller] = (data[:controller].to_s.split + ["tam-select"]).uniq.join(" ")
+    data[:tam_select_options_value] = options.to_json
+    select_tag(name, option_tags, html_options, &block)
+  end
+
+  def tam_select_options(**overrides)
+    {
+      searchable: true,
+      clearable: true,
+      creatable: false,
+      placeholder: "Select…"
+    }.merge(overrides)
+  end
+end

data/rails/app/inputs/tam_select_input.rb

@@ -0,0 +1,30 @@
+class TamSelectInput < SimpleForm::Inputs::CollectionSelectInput
+  def input(wrapper_options = nil)
+    attributes = merge_wrapper_options(input_html_options, wrapper_options)
+    label_method, value_method = detect_collection_methods
+    tam_options = attributes.delete(:tam_options) || {}
+    data = attributes[:data] ||= {}
+    data[:controller] = (data[:controller].to_s.split + ["tam-select"]).uniq.join(" ")
+    data[:tam_select_options_value] = defaults.merge(tam_options).to_json
+
+    @builder.collection_select(
+      attribute_name,
+      collection,
+      value_method,
+      label_method,
+      input_options,
+      attributes
+    )
+  end
+
+  private
+
+  def defaults
+    {
+      searchable: options.fetch(:searchable, true),
+      creatable: options.fetch(:creatable, false),
+      clearable: options.fetch(:clearable, true),
+      placeholder: options[:placeholder] || options[:prompt] || "Select…"
+    }
+  end
+end