swal_rails 0.3.1.beta1 → 0.3.1.beta2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9e9ac64c06c6de5525bf1964f4c866b72b3a5fc4fb42fed239778cc94e0bc57c
-  data.tar.gz: abefde5449478e377516fb40b78087fb89b60f73c60788422309e0930e278643
+  metadata.gz: 8bb7a427540f6d06a45d6f18b7a4b29c9771a4890080bbab90dc6806e59502fb
+  data.tar.gz: e39bf17dfad033eb1d23b57710ae48f729ebb26da77139ef359a12f3bf88732b
 SHA512:
-  metadata.gz: 455ee6bc8175ee826535fcfbb7be404f9b56ca2d2a92715f0fe47d818d10521257bcdb8bd640b7b344e26e980aeaa5948d2d237fa097df0aa0e2c534a6fd337a
-  data.tar.gz: db9ff1404a3e0b33b0e9b70cb04feb9386c2e94b5dad486477d18b319b16d9c64e055eb47a726f491447bcba326010b08f3565de07f343ad3a0033f6634cc925
+  metadata.gz: 72f6a4f2df33ecc991599e09e59bcbcb46f9f328b27803c53c0d4d06f3ad6eb665d9fe23170850e52cf1b277ce211cffe6762edf300ca8525225a3fc8d798cc1
+  data.tar.gz: 770db1bd51acd17a16e0601d67217bd44428d38fdcff73abcc753192371ce49a5ba451735dd181b476465f90db5de65c6ece483a8ed20d79ec8f30106f427133

data/CHANGELOG.md

@@ -6,6 +6,53 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.3.1.beta2] - 2026-04-24
+
+### Fixed
+- Flash runtime now also boots on `turbo:render`, not just `turbo:load`.
+  Form submissions that render in place (`render :index, status:
+  :unprocessable_entity` for `flash.now` payloads) trigger `turbo:render`
+  but not `turbo:load`, so the `swal-flash` meta tag emitted in the new
+  body never reached the runtime. The existing `data-swal-consumed`
+  guard on the meta tag dedupes the double-fire on full navigations.
+- Stacked-mode clones now render at SA2's standard toast width (360px,
+  capped at viewport width minus 2rem) instead of stretching to the full
+  page. The fix applies CSS to `#swal-rails-stack` mirroring SA2's
+  internal `body.swal2-toast-shown .swal2-container` rules — necessary
+  because the cloned popups live outside SA2's container hierarchy.
+- Confirm `:turbo_override` / `:both` now writes to
+  `Turbo.config.forms.confirm` first (Turbo 8.1+) and only falls back to
+  the deprecated `Turbo.setConfirmMethod`. Silences the Turbo deprecation
+  warning logged on every page load.
+
+### Changed
+- `default_options` no longer ships with `focusConfirm: true` /
+  `returnFocus: true`. Both are already SA2's internal defaults, so
+  behavior is unchanged — but listing them explicitly made SA2 warn
+  ("incompatible with toasts") on every toast fire. The generator
+  template is updated to match.
+- `flash_map[:alert]` and `flash_map[:error]` now default to a toast
+  (top-end, 4s, error icon) instead of a blocking modal. This makes every
+  built-in flash key a toast out of the box — more consistent and more in
+  line with how Rails apps typically use `flash[:alert]`. Users who want
+  the old modal behavior can still opt in:
+  `config.flash_map[:alert] = { icon: "error", toast: false }`.
+
+### Added
+- `config.flash_array_mode` (`:sequential` default | `:stacked`) — how a
+  multi-entry flash payload is played. Sequential waits for each Swal to
+  close before firing the next (current behavior); stacked renders every
+  toast in parallel in a fixed top-right container with a configurable
+  delay between each appearance.
+- `config.flash_stack_delay` (ms, default 500) — gap between stacked
+  toasts in `:stacked` mode.
+- `swal_flash(key, messages, mode:, delay:, now:, **options)` helper,
+  available in both controllers and views. Lets a single call override the
+  global mode/delay and merge extra SA2 options for the payload:
+  `swal_flash :alert, @post.errors.full_messages, mode: :stacked, delay: 300`.
+- Reserved meta-keys `_arrayMode` / `_stackDelay` on flash entry options,
+  stripped by the JS runtime before being passed to `Swal.fire`.
+
 ## [0.3.1.beta1] - 2026-04-21
 
 ### Changed

data/README.md

@@ -83,7 +83,7 @@ then — it's on **v11** now) and were built for the Rails 5 / UJS era.
 
 - 🎨 **SweetAlert2 v11** vendored and pinned — no CDN, no surprise upgrades.
 - ⚡ **Three asset pipelines**: Importmap (default), jsbundling, Sprockets.
-- 🔔 **Auto-wired flash** — `flash[:notice]` → toast, `flash[:alert]` → modal, fully mappable per key.
+- 🔔 **Auto-wired flash** — `flash[:notice]` / `flash[:alert]` → toast, stackable, fully mappable per key.
 - 🛡️ **Turbo confirmations** — replace the native `confirm()` globally **or** opt-in per element.
 - 🎮 **Stimulus controller** (`data-controller="swal"`) for declarative popups.
 - 🧱 **Ruby view helpers** — `swal_tag`, `swal_config_meta_tag`, `swal_flash_meta_tag`.
@@ -204,12 +204,16 @@ SwalRails.configure do |config|
   }
 
   # ─── Flash → Swal mapping (per key) ──────────────────────────────────
-  config.flash_map[:notice]  = { icon: "success", toast: true,  position: "top-end", timer: 3000 }
-  config.flash_map[:success] = { icon: "success", toast: true,  position: "top-end", timer: 3000 }
-  config.flash_map[:alert]   = { icon: "error",   toast: false }
-  config.flash_map[:error]   = { icon: "error",   toast: false }
-  config.flash_map[:warning] = { icon: "warning", toast: true,  position: "top-end", timer: 4000 }
-  config.flash_map[:info]    = { icon: "info",    toast: true,  position: "top-end", timer: 3000 }
+  config.flash_map[:notice]  = { icon: "success", toast: true, position: "top-end", timer: 3000 }
+  config.flash_map[:success] = { icon: "success", toast: true, position: "top-end", timer: 3000 }
+  config.flash_map[:alert]   = { icon: "error",   toast: true, position: "top-end", timer: 4000 }
+  config.flash_map[:error]   = { icon: "error",   toast: true, position: "top-end", timer: 4000 }
+  config.flash_map[:warning] = { icon: "warning", toast: true, position: "top-end", timer: 4000 }
+  config.flash_map[:info]    = { icon: "info",    toast: true, position: "top-end", timer: 3000 }
+
+  # ─── Multi-entry flash playback ─────────────────────────────────────
+  config.flash_array_mode  = :sequential  # :sequential | :stacked
+  config.flash_stack_delay = 500          # ms between stacked toasts
 
   # ─── I18n scope (for button labels) ──────────────────────────────────
   config.i18n_scope = "swal_rails"
@@ -228,8 +232,8 @@ end
 Any flash set from a controller is rendered automatically on page load:
 
 ```ruby
-flash[:notice] = "Profile updated"   # → toast top-right
-flash[:alert]  = "Could not save"    # → modal
+flash[:notice] = "Profile updated"   # → success toast top-right
+flash[:alert]  = "Could not save"    # → error toast top-right (since 0.3.1.beta2)
 ```
 
 Arrays are expanded into one popup per message — handy for model errors:
@@ -248,6 +252,38 @@ flash[:notice] = { text: "Deployed!", icon: "rocket", timer: 5000, toast: true }
 # → ignores flash_map[:notice], fires a 5-second rocket toast
 ```
 
+#### Multi-entry playback: sequential vs stacked
+
+When more than one flash entry is set in a single request — either through an
+array of messages under one key, or multiple distinct keys — the runtime
+picks one of two playback modes (configurable via `config.flash_array_mode`):
+
+| Mode           | Behavior |
+| -------------- | -------- |
+| `:sequential`  | **(default)** Each Swal fires only after the previous one closes — chained via Promise callbacks. Predictable but slow on long lists. |
+| `:stacked`     | All entries fire in parallel into a fixed top-right container, stacking vertically. Each appears `flash_stack_delay` ms after the previous (default 500ms), then runs its own timer independently. Any `toast: false` entry is forced to toast in this mode. |
+
+#### `swal_flash` helper (per-request override)
+
+For one-off overrides without touching the global config, use `swal_flash`
+from controllers or views:
+
+```ruby
+# Pile up validation errors as a stack of toasts with a quicker 300ms cadence
+swal_flash :alert, @post.errors.full_messages, mode: :stacked, delay: 300
+
+# Same mode but over flash.now (for `render`, not `redirect_to`)
+swal_flash :alert, "Form incomplete", now: true
+
+# Extra SA2 options are merged into every entry
+swal_flash :notice, "Deployed!", icon: "rocket", timer: 5000
+```
+
+Signature: `swal_flash(key, messages, mode: nil, delay: nil, now: false, **options)`.
+`mode:` and `delay:` are stored on the flash entry as reserved `_arrayMode` /
+`_stackDelay` meta-keys, extracted by the JS runtime before the options are
+handed to `Swal.fire` — they never leak into SA2.
+
 Behind the scenes, the engine serializes the flash into a meta tag
 (`<meta name="swal-flash" content="...">`) and the JS runtime reads it and
 calls `Swal.fire(...)` with your per-key options.
@@ -488,6 +524,8 @@ SwalRails.reset_configuration!             # resets to defaults (test fixture he
 | `expose_window_swal`     | Boolean | `true`             | When `true`, `window.Swal` is set to the mixed-in `Swal` instance after boot (useful for console debugging and inline scripts). |
 | `default_options`        | Hash    | see below          | Merged into **every** `Swal.fire(...)` call via `Swal.mixin(...)`. |
 | `flash_map`              | Hash    | see below          | Flash-key → SA2 options mapping. Keys normalized to symbols. Non-Hash assignment raises `ArgumentError`. |
+| `flash_array_mode`       | Symbol  | `:sequential`      | How multi-entry flash payloads are played: `:sequential` (one at a time, waits for close) or `:stacked` (all in parallel, stacked top-right). Validated. |
+| `flash_stack_delay`      | Integer | `500`              | Milliseconds between each toast's appearance in `:stacked` mode. |
 | `i18n_scope`             | String  | `"swal_rails"`     | I18n scope used to look up `confirm_button_text`, `cancel_button_text`, `deny_button_text`, `close_button_aria_label`. Non-string values are coerced. |
 
 `confirm_mode` accepted values:
@@ -509,15 +547,18 @@ SwalRails.reset_configuration!             # resets to defaults (test fixture he
 
 ```ruby
 {
-  notice:  { icon: "success", toast: true,  position: "top-end", timer: 3000, timerProgressBar: true, showConfirmButton: false },
-  success: { icon: "success", toast: true,  position: "top-end", timer: 3000, timerProgressBar: true, showConfirmButton: false },
-  alert:   { icon: "error",   toast: false, timer: nil },
-  error:   { icon: "error",   toast: false, timer: nil },
-  warning: { icon: "warning", toast: true,  position: "top-end", timer: 4000, timerProgressBar: true, showConfirmButton: false },
-  info:    { icon: "info",    toast: true,  position: "top-end", timer: 3000, timerProgressBar: true, showConfirmButton: false }
+  notice:  { icon: "success", toast: true, position: "top-end", timer: 3000, timerProgressBar: true, showConfirmButton: false },
+  success: { icon: "success", toast: true, position: "top-end", timer: 3000, timerProgressBar: true, showConfirmButton: false },
+  alert:   { icon: "error",   toast: true, position: "top-end", timer: 4000, timerProgressBar: true, showConfirmButton: false },
+  error:   { icon: "error",   toast: true, position: "top-end", timer: 4000, timerProgressBar: true, showConfirmButton: false },
+  warning: { icon: "warning", toast: true, position: "top-end", timer: 4000, timerProgressBar: true, showConfirmButton: false },
+  info:    { icon: "info",    toast: true, position: "top-end", timer: 3000, timerProgressBar: true, showConfirmButton: false }
 }
 ```
 
+> 💡 **Prefer a modal for errors?** Override in your initializer:
+> `config.flash_map[:alert] = { icon: "error", toast: false }`.
+
 #### `to_client_payload` (internal, read-only)
 
 Serialization contract consumed by the JS runtime via the
@@ -530,7 +571,9 @@ Serialization contract consumed by the JS runtime via the
   exposeWindowSwal:     Boolean,
   defaultOptions:       Hash,
   flashMap:             Hash,
-  i18n:                 Hash   # only keys whose translation is present
+  flashArrayMode:       Symbol,  # :sequential | :stacked
+  flashStackDelay:      Integer, # ms
+  i18n:                 Hash     # only keys whose translation is present
 }
 ```
 

data/app/assets/javascripts/swal_rails/confirm.js

@@ -54,10 +54,20 @@ const confirmFlow = (Swal, message, element) => {
 }
 
 const installTurboOverride = (Swal) => {
-  if (typeof window.Turbo === "undefined" || !window.Turbo.setConfirmMethod) return false
-
-  window.Turbo.setConfirmMethod((message, element) => confirmFlow(Swal, message, element))
-  return true
+  if (typeof window.Turbo === "undefined") return false
+  const handler = (message, element) => confirmFlow(Swal, message, element)
+  // Turbo 8.1+ renamed the API to `Turbo.config.forms.confirm`. The legacy
+  // `setConfirmMethod` still works but emits a deprecation warning. Prefer
+  // the new path, fall back to the old one for older Turbo versions.
+  if (window.Turbo.config?.forms) {
+    window.Turbo.config.forms.confirm = handler
+    return true
+  }
+  if (typeof window.Turbo.setConfirmMethod === "function") {
+    window.Turbo.setConfirmMethod(handler)
+    return true
+  }
+  return false
 }
 
 const installDataAttribute = (Swal) => {

data/app/assets/javascripts/swal_rails/flash.js

@@ -1,9 +1,119 @@
+// Read the meta tag exactly once per page load. Boot() fires on both
+// DOMContentLoaded and turbo:load, so without this guard an array flash
+// would have its fireNext chain launched twice, racing and cascading via
+// Swal.fire's replace-current-popup behavior — only the last message wins.
 const readFlash = () => {
   const el = document.querySelector('meta[name="swal-flash"]')
-  if (!el) return []
+  if (!el || el.dataset.swalConsumed === "1") return []
+  el.dataset.swalConsumed = "1"
   try { return JSON.parse(el.getAttribute("content")) || [] } catch { return [] }
 }
 
+// Keys attached by `swal_flash` helper for per-request mode / delay override.
+// Stripped from the options before being passed to Swal.fire so they never
+// leak into SA2.
+const META_KEYS = ["_arrayMode", "_stackDelay"]
+
+const extractMeta = (queue) => {
+  let mode = null
+  let delay = null
+  for (const item of queue) {
+    if (mode === null && item._arrayMode) mode = item._arrayMode
+    if (delay === null && item._stackDelay != null) delay = item._stackDelay
+    for (const k of META_KEYS) delete item[k]
+  }
+  return { mode, delay }
+}
+
+const STACK_ID = "swal-rails-stack"
+
+const ensureStackContainer = () => {
+  let el = document.getElementById(STACK_ID)
+  if (!el) {
+    el = document.createElement("div")
+    el.id = STACK_ID
+    // 360px matches SA2's `body.swal2-toast-shown .swal2-container` width;
+    // without it the cloned popups inherit `width: 100%` from SA2 and
+    // visually span the whole screen.
+    el.style.cssText = [
+      "position:fixed",
+      "top:1rem",
+      "right:1rem",
+      "width:360px",
+      "max-width:calc(100vw - 2rem)",
+      "display:flex",
+      "flex-direction:column",
+      "gap:.5rem",
+      "z-index:10000",
+      "pointer-events:none"
+    ].join(";")
+    document.body.appendChild(el)
+  }
+  return el
+}
+
+const fireSequential = (Swal, queue) => {
+  const fireNext = () => {
+    const opts = queue.shift()
+    if (!opts) return
+    Swal.fire(opts).then(fireNext)
+  }
+  fireNext()
+}
+
+// SA2 is singleton — two concurrent Swal.fire calls collapse into one
+// popup (the second replaces the first). To stack multiple toasts we let
+// SA2 render each popup, clone it into its own slot, then close the
+// original fast so the next fire is unblocked. The clones live on in our
+// stack with their own timer and click-to-dismiss handlers. Empiler des
+// modales bloquantes n'a pas de sens — on force toast: true.
+const fireStacked = async (Swal, queue, delay) => {
+  const stack = ensureStackContainer()
+  for (let i = 0; i < queue.length; i++) {
+    const opts = queue[i]
+    const slot = document.createElement("div")
+    slot.className = "swal-rails-stack-slot"
+    slot.style.cssText = "width:100%;pointer-events:auto;"
+    stack.appendChild(slot)
+
+    const timerMs = opts.timer
+    await new Promise((resolve) => {
+      Swal.fire({
+        ...opts,
+        toast: true,
+        // Close the SA2 original immediately; the clone in `slot` persists.
+        // Animations disabled on the decoy so the clone captures the popup
+        // in its normal "shown" state (no opacity-0 from close transition).
+        timer: 1,
+        timerProgressBar: false,
+        showClass: { popup: "", backdrop: "", icon: "" },
+        hideClass: { popup: "", backdrop: "", icon: "" },
+        didRender: (popup) => {
+          const clone = popup.cloneNode(true)
+          clone.style.opacity = ""
+          clone.querySelectorAll(".swal2-timer-progress-bar-container").forEach((e) => e.remove())
+          // SA2 adds `.swal2-icon-show` only after didOpen, but we clone
+          // earlier (in didRender) to beat the close animation. Apply it
+          // manually so the icon's SVG is visibly drawn in the clone.
+          clone.querySelectorAll(".swal2-icon").forEach((icon) => icon.classList.add("swal2-icon-show"))
+          slot.appendChild(clone)
+          const dismiss = () => {
+            if (slot.isConnected) slot.remove()
+            if (stack.isConnected && stack.children.length === 0) stack.remove()
+          }
+          clone.querySelector(".swal2-close")?.addEventListener("click", dismiss)
+          if (timerMs) setTimeout(dismiss, timerMs)
+        },
+        didClose: () => resolve()
+      })
+    })
+
+    if (i < queue.length - 1 && delay > 0) {
+      await new Promise((r) => setTimeout(r, delay))
+    }
+  }
+}
+
 export const installFlash = (Swal, config) => {
   const flashes = readFlash()
   if (!flashes.length) return
@@ -15,10 +125,14 @@ export const installFlash = (Swal, config) => {
     return { ...spec, ...(flash.options || {}) }
   })
 
-  const fireNext = () => {
-    const opts = queue.shift()
-    if (!opts) return
-    Swal.fire(opts).then(fireNext)
+  const meta = extractMeta(queue)
+  const mode = meta.mode || config.flashArrayMode || "sequential"
+  const delay = meta.delay != null ? meta.delay
+    : (config.flashStackDelay != null ? config.flashStackDelay : 500)
+
+  if (mode === "stacked" && queue.length > 1) {
+    fireStacked(Swal, queue, delay)
+  } else {
+    fireSequential(Swal, queue)
   }
-  fireNext()
 }

data/app/assets/javascripts/swal_rails/index.js

@@ -56,7 +56,14 @@ const ready = (fn) => {
 }
 
 ready(boot)
+// `turbo:load` covers full Turbo Drive navigations + initial page loads.
+// `turbo:render` additionally covers form submissions that render with
+// a non-redirect status (e.g. 422 unprocessable_entity for `flash.now`)
+// — Turbo replaces the body but does NOT fire turbo:load in that path.
+// The `data-swal-consumed` guard on the meta tag dedupes the double-fire
+// on full navigations where both events run.
 document.addEventListener("turbo:load", boot)
+document.addEventListener("turbo:render", boot)
 
 export { Swal }
 export default Swal

data/lib/generators/swal_rails/install/templates/initializer.rb

@@ -15,19 +15,29 @@ SwalRails.configure do |config|
   config.respect_reduced_motion = true
 
   # Default options merged into every Swal.fire call.
+  # Note: `focusConfirm` / `returnFocus` are intentionally omitted — SA2
+  # already defaults both to `true`, and listing them explicitly makes SA2
+  # warn on every toast ("incompatible with toasts").
   config.default_options = {
     buttonsStyling: true,
-    reverseButtons: false,
-    focusConfirm: true,
-    returnFocus: true
+    reverseButtons: false
   }
 
   # Map Rails flash keys to SweetAlert2 options.
   # Set a key to nil to silence it. Customize icon/toast/position/timer per key.
-  config.flash_map[:notice]  = { icon: "success", toast: true,  position: "top-end", timer: 3000, timerProgressBar: true, showConfirmButton: false }
-  config.flash_map[:success] = { icon: "success", toast: true,  position: "top-end", timer: 3000, timerProgressBar: true, showConfirmButton: false }
-  config.flash_map[:alert]   = { icon: "error",   toast: false }
-  config.flash_map[:error]   = { icon: "error",   toast: false }
-  config.flash_map[:warning] = { icon: "warning", toast: true,  position: "top-end", timer: 4000, timerProgressBar: true, showConfirmButton: false }
-  config.flash_map[:info]    = { icon: "info",    toast: true,  position: "top-end", timer: 3000, timerProgressBar: true, showConfirmButton: false }
+  config.flash_map[:notice]  = { icon: "success", toast: true, position: "top-end", timer: 3000, timerProgressBar: true, showConfirmButton: false }
+  config.flash_map[:success] = { icon: "success", toast: true, position: "top-end", timer: 3000, timerProgressBar: true, showConfirmButton: false }
+  config.flash_map[:alert]   = { icon: "error",   toast: true, position: "top-end", timer: 4000, timerProgressBar: true, showConfirmButton: false }
+  config.flash_map[:error]   = { icon: "error",   toast: true, position: "top-end", timer: 4000, timerProgressBar: true, showConfirmButton: false }
+  config.flash_map[:warning] = { icon: "warning", toast: true, position: "top-end", timer: 4000, timerProgressBar: true, showConfirmButton: false }
+  config.flash_map[:info]    = { icon: "info",    toast: true, position: "top-end", timer: 3000, timerProgressBar: true, showConfirmButton: false }
+
+  # How multiple flash entries are played when more than one is set in a
+  # single request (or a flash key carries an array of messages).
+  #   :sequential — one after the other, each waits for the previous to close (default)
+  #   :stacked    — fire all in parallel, stacked vertically in a top-right container,
+  #                 with `flash_stack_delay` ms between each appearance
+  # Override per-request with `swal_flash :alert, msgs, mode: :stacked, delay: 300`.
+  config.flash_array_mode  = :sequential
+  config.flash_stack_delay = 500
 end

data/lib/swal_rails/configuration.rb

@@ -11,24 +11,30 @@ module SwalRails
   #   end
   class Configuration
     CONFIRM_MODES = %i[off data_attribute turbo_override both].freeze
+    FLASH_ARRAY_MODES = %i[sequential stacked].freeze
 
     attr_accessor :default_options,
                   :flash_keys_as_meta,
                   :respect_reduced_motion,
-                  :expose_window_swal
-    attr_reader :confirm_mode, :flash_map, :i18n_scope
+                  :expose_window_swal,
+                  :flash_stack_delay
+    attr_reader :confirm_mode, :flash_map, :i18n_scope, :flash_array_mode
 
     def initialize
       @confirm_mode = :data_attribute
       @flash_keys_as_meta = true
       @respect_reduced_motion = true
       @expose_window_swal = true
+      @flash_array_mode = :sequential
+      @flash_stack_delay = 500
       @i18n_scope = "swal_rails"
+      # `focusConfirm` / `returnFocus` are intentionally omitted: SA2 already
+      # defaults both to `true` internally, and passing them explicitly makes
+      # SA2 warn on every toast ("incompatible with toasts"). Listing them
+      # here would be a no-op behaviorally and a noise generator.
       @default_options = {
         buttonsStyling: true,
-        reverseButtons: false,
-        focusConfirm: true,
-        returnFocus: true
+        reverseButtons: false
       }
       @flash_map = default_flash_map
     end
@@ -40,6 +46,15 @@ module SwalRails
       @confirm_mode = value
     end
 
+    def flash_array_mode=(value)
+      value = value.to_sym
+      unless FLASH_ARRAY_MODES.include?(value)
+        raise ArgumentError, "flash_array_mode must be one of #{FLASH_ARRAY_MODES.inspect}, got #{value.inspect}"
+      end
+
+      @flash_array_mode = value
+    end
+
     def i18n_scope=(value)
       @i18n_scope = value.to_s
     end
@@ -59,6 +74,8 @@ module SwalRails
         exposeWindowSwal: expose_window_swal,
         defaultOptions: default_options,
         flashMap: flash_map,
+        flashArrayMode: flash_array_mode,
+        flashStackDelay: flash_stack_delay,
         i18n: i18n_payload
       }
     end
@@ -69,8 +86,8 @@ module SwalRails
       {
         notice: { icon: "success", toast: true, position: "top-end", timer: 3000, timerProgressBar: true, showConfirmButton: false },
         success: { icon: "success", toast: true, position: "top-end", timer: 3000, timerProgressBar: true, showConfirmButton: false },
-        alert: { icon: "error",   toast: false, timer: nil },
-        error: { icon: "error",   toast: false, timer: nil },
+        alert: { icon: "error",   toast: true, position: "top-end", timer: 4000, timerProgressBar: true, showConfirmButton: false },
+        error: { icon: "error",   toast: true, position: "top-end", timer: 4000, timerProgressBar: true, showConfirmButton: false },
         warning: { icon: "warning", toast: true, position: "top-end", timer: 4000, timerProgressBar: true, showConfirmButton: false },
         info: { icon: "info", toast: true, position: "top-end", timer: 3000, timerProgressBar: true, showConfirmButton: false }
       }

data/lib/swal_rails/engine.rb

@@ -40,6 +40,9 @@ module SwalRails
     initializer "swal_rails.helpers" do
       ActiveSupport.on_load(:action_controller_base) do
         helper SwalRails::Helpers
+        # Expose `swal_flash` as a controller method so controllers can
+        # set flash entries with per-request mode/delay overrides.
+        include SwalRails::Helpers
       end
       ActiveSupport.on_load(:action_view) do
         include SwalRails::Helpers

data/lib/swal_rails/helpers.rb

@@ -50,6 +50,48 @@ module SwalRails
       message.is_a?(Array) ? message : [message]
     end
 
+    # Controller/view sugar for setting a flash entry with per-request
+    # overrides of the global flash_array_mode / flash_stack_delay config.
+    #
+    #   swal_flash :alert, @post.errors.full_messages, mode: :stacked, delay: 300
+    #   swal_flash :notice, "Deployed!", icon: "rocket", timer: 5000
+    #   swal_flash :alert, "Oops", now: true            # uses flash.now
+    #
+    # `mode:` — :sequential | :stacked (overrides config.flash_array_mode for this payload)
+    # `delay:` — ms between stacked toasts (overrides config.flash_stack_delay)
+    # `now:`   — write to flash.now (for rendered responses, no redirect)
+    # `**options` — any extra SA2 options merged into each entry
+    #
+    # Meta-keys `_arrayMode` / `_stackDelay` are reserved — the JS runtime
+    # strips them before passing options to Swal.fire.
+    def swal_flash(key, messages, mode: nil, delay: nil, now: false, **options) # rubocop:disable Metrics/ParameterLists
+      entries = build_swal_flash_entries(messages, swal_flash_meta(mode, delay), options)
+      return if entries.empty?
+
+      (now ? flash.now : flash)[key] = entries.size == 1 ? entries.first : entries
+    end
+
+    private
+
+    def swal_flash_meta(mode, delay)
+      meta = {}
+      meta[:_arrayMode] = mode.to_s if mode
+      meta[:_stackDelay] = Integer(delay) if delay
+      meta
+    end
+
+    def build_swal_flash_entries(messages, meta, options)
+      list = messages.is_a?(Array) ? messages : [messages]
+      list.filter_map do |m|
+        next if m.blank?
+
+        base = m.is_a?(Hash) ? m.symbolize_keys : { text: m.to_s }
+        base.merge(options).merge(meta)
+      end
+    end
+
+    public
+
     # Generates an inline `<script>` that fires a single Swal.
     #
     # Usage: `<%= swal_tag(title: "Hi", icon: "info") %>`

data/lib/swal_rails/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module SwalRails
-  VERSION = "0.3.1.beta1"
+  VERSION = "0.3.1.beta2"
   SWEETALERT2_VERSION = "11.26.24"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: swal_rails
 version: !ruby/object:Gem::Version
-  version: 0.3.1.beta1
+  version: 0.3.1.beta2
 platform: ruby
 authors:
 - Florian Gagnaire
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-04-21 00:00:00.000000000 Z
+date: 2026-04-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: railties