RubyGems - modal_stack - Versions diffs - 0.1.1 → 0.2.0 - Mend

modal_stack 0.1.1 → 0.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (17) hide show

checksums.yaml +4 -4
data/CHANGELOG.md +17 -0
data/README.md +50 -6
data/app/assets/javascripts/modal_stack.js +100 -22
data/app/javascript/modal_stack/controllers/modal_stack_controller.js +48 -13
data/app/javascript/modal_stack/orchestrator.js +52 -3
data/app/javascript/modal_stack/orchestrator.test.js +50 -0
data/app/javascript/modal_stack/runtime.js +36 -2
data/app/javascript/modal_stack/runtime.test.js +70 -1
data/app/javascript/modal_stack/state.js +121 -1
data/app/javascript/modal_stack/state.test.js +83 -1
data/lib/generators/modal_stack/install/templates/initializer.rb +7 -1
data/lib/modal_stack/configuration.rb +37 -3
data/lib/modal_stack/helpers/modal_stack_assets_helper.rb +12 -4
data/lib/modal_stack/version.rb +1 -1
data/lib/modal_stack.rb +1 -1
metadata +2 -2

checksums.yaml CHANGED Viewed

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 44bb2750129e5c72cb364e6fd217603b35e838cd2b42d8f7d55b93902cb1409c
-  data.tar.gz: 76aa67df55336d851d2c11ce06d00ab99fd1959bb4542331dba3b129ad3cacad
+  metadata.gz: 5d872f05608ece432767e38bbe58ec38bf97c60a0cd90ccf1afd37f41f7f6192
+  data.tar.gz: 3da69811422baf2e1e7927bae0dbe46cf75311b5214e34e90e0a04e8aa691250
 SHA512:
-  metadata.gz: 64e9cb4d64f3cabb2d78b3b7f37aa608300008cbab3195fb1cc3f0c57f9b7492907577d0fe4db4415aaebc75a54226ab9114a632ce905864d8de96d8b078766e
-  data.tar.gz: 2f525716be7b232ada7ce0a3499c859707e6e61e5e4990ae6097b416e876e05f62e56d5d945ac5819aeb355a464811213fb6b9f1bd149ab4b849ff87d75c42ad
+  metadata.gz: 3d9470889c9fa8b2d967174818eb813a90657baac94a70edadf3f7a416400e364cc5e15ed9b7274544b138f8b5647189e21143b14aa27d67cac79ae711822d20
+  data.tar.gz: 5dcdab2a2dca8c1b57b67e62f1daff68cc3b04395e5e66d9a3da933de02caef78460116c4b097fb040fa33011a83eb79f0645d6e273e91ad21ec552a27023d1b

data/CHANGELOG.md CHANGED Viewed

@@ -12,6 +12,23 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Fixed
+## [0.2.0] - 2026-05-03
+### Added
+- **`max_depth` enforcement**: pushes past the cap are now intercepted by the reducer. The new `config.max_depth_strategy` (`:warn` default, `:raise`, `:silent`) controls behaviour. The cap can be disabled with `config.max_depth = nil`.
+- **`ModalStackDepthError`** JS class, thrown by `push()` under the `:raise` strategy. Exported from `state.js`.
+- **Scrollbar-width compensation**: `BrowserRuntime#lockScroll` now sets `--modal-stack-scrollbar-width` on `<html>` so the host CSS can offset fixed elements without layout shift. The CSS variable was already referenced by the Tailwind / Bootstrap / vanilla presets — this completes the wiring.
+- **`modal_stack:error` custom event**: malformed Turbo Stream payloads (bad `data-*`, fetch failures) no longer crash the page. The error is logged and re-emitted as a bubbling `CustomEvent` on the `<dialog>` so apps can surface UI feedback.
+- **JSDoc** on the JS public surface (`state.js`, `runtime.js`, `orchestrator.js`) — including `Layer`, `Stack`, `Command`, and `Transition` typedefs.
+- New tests: max_depth strategies, scrollbar-width compensation, missing-handler error message, default_dismissible/max_depth/max_depth_strategy validation, dialog tag wiring.
+### Changed
+- `Configuration#default_dismissible=` now raises `ArgumentError` on non-boolean values (was a silent `attr_accessor`).
+- `Configuration#max_depth=` now coerces strings, accepts `nil`, and rejects non-positive integers.
+- `Orchestrator` constructor accepts `maxDepth` + `maxDepthStrategy`. The Stimulus controller forwards them via `data-modal-stack-max-depth-value` / `data-modal-stack-max-depth-strategy-value`, which `modal_stack_dialog_tag` now emits from the gem's configuration.
+- The "runtime missing handler" error message now lists the runtime's known handlers and the current stack depth.
+- `INITIALIZER_VERSION` bumped to `0.2.0` because the generator template gained `config.max_depth_strategy`.
 ## [0.1.1] - 2026-05-02
 ### Added

data/README.md CHANGED Viewed

@@ -210,7 +210,8 @@ ModalStack.configure do |config|
   config.default_dismissible = true     # ESC + backdrop click close the layer
   # ─── Behavior ─────────────────────────────────────────────────────
-  config.max_depth              = 5     # hard cap on nested layers
+  config.max_depth              = 5     # hard cap on nested layers (nil to disable)
+  config.max_depth_strategy     = :warn # :warn | :raise | :silent
   config.respect_reduced_motion = true  # honor prefers-reduced-motion
   config.replace_turbo_confirm  = false # use modal_stack confirmations for data-turbo-confirm
@@ -393,8 +394,17 @@ The `<dialog>` itself is opened on first push, closed on last pop. Page
 scroll is locked while any layer is open (`<body data-modal-stack-locked>`)
 so the page beneath doesn't scroll under your finger on touch devices.
-`max_depth` (default `5`) is a hard ceiling — pushing past it raises a
-runtime error, on the assumption that you have a state-machine bug.
+`max_depth` (default `5`) is a hard ceiling on the number of stacked layers,
+on the assumption that going past it usually means you have a state-machine
+bug. The behaviour is controlled by `config.max_depth_strategy`:
+| Strategy   | Behaviour                                                            |
+| ---------- | -------------------------------------------------------------------- |
+| `:warn`    | (default) The push is dropped and `console.warn` logs a message.     |
+| `:raise`   | The JS runtime throws `ModalStackDepthError` (caught by the stream-action error boundary, see below). |
+| `:silent`  | The push is dropped without logging.                                 |
+Set `config.max_depth = nil` to disable the cap entirely.
 ---
@@ -416,7 +426,8 @@ ModalStack.reset_configuration!         # test-fixture helper
 | `default_size`               | Symbol  | `:md`                    | `:sm`, `:md`, `:lg`, `:xl`. Validated. |
 | `default_dismissible`        | Boolean | `true`                   | Default for `dismissible:` when omitted. |
 | `default_classes`            | Hash    | `{ ... }`                | Hash of extra CSS class strings keyed by `:modal_panel`, `:drawer_panel`, `:bottom_sheet_panel`, `:confirmation_panel`. Useful for adding utility classes on top of the chosen preset. |
-| `max_depth`                  | Integer | `5`                      | Hard cap on stack depth — pushing past it raises. |
+| `max_depth`                  | Integer | `5`                      | Hard cap on stack depth. Coerced from strings; set to `nil` to disable. Validated. |
+| `max_depth_strategy`         | Symbol  | `:warn`                  | One of `:warn`, `:raise`, `:silent`. See [Stack depth & inertness](#stack-depth--inertness). Validated. |
 | `request_header`             | String  | `"X-Modal-Stack-Request"` | HTTP header used by the JS runtime to signal stack-originated fetches. Read by `modal_stack_request?`. |
 | `dialog_id`                  | String  | `"modal-stack-root"`     | The id of the singleton `<dialog>`. Override only on name collision. |
 | `stack_root_data_attribute`  | String  | `"modal-stack"`          | The Stimulus `data-controller` value attached to the `<dialog>`. |
@@ -503,11 +514,11 @@ The package exports a small functional core + a browser adapter:
 import {
   // pure reducer — no IO, no DOM
   createStack, push, pop, replaceTop, closeAll, handlePopstate,
-  snapshot, restore, topLayer, VARIANTS,
+  snapshot, restore, topLayer, VARIANTS, ModalStackDepthError,
   // orchestrator + browser runtime
   Orchestrator, BrowserRuntime,
-  FRAGMENT_HEADER, SNAPSHOT_KEY,
+  FRAGMENT_HEADER, SNAPSHOT_KEY, SCROLLBAR_WIDTH_VAR,
 } from "modal_stack"
 import { install } from "modal_stack/install"
@@ -518,6 +529,39 @@ entry point your `application.js` calls. The reducer is
 side-effect-free and 100% covered; the browser adapter is the only
 file that touches `<dialog>`, `history`, `fetch`, and `sessionStorage`.
+The reducer's command type vocabulary (`mountLayer`, `morphTopLayer`,
+`unmountTopLayer`, `unmountAllLayers`, `showDialog`, `closeDialog`,
+`lockScroll`, `unlockScroll`, `inertLayer`, `pushHistory`,
+`replaceHistory`, `historyBack`, `rebuildFromSnapshot`, `persistSnapshot`,
+`clearSnapshot`) forms the contract between `state.js` and any runtime —
+swap in a custom adapter (e.g. for Hotwire Native) by implementing one
+method per command name.
+#### Custom events
+The `<dialog>` emits two `CustomEvent`s that bubble to `document`:
+| Event                  | `detail`                                    | Fired when |
+| ---------------------- | ------------------------------------------- | ---------- |
+| `modal_stack:ready`    | `{ stackId }`                               | The Stimulus controller has connected and the orchestrator is ready. |
+| `modal_stack:error`    | `{ action, error }`                         | A Turbo Stream action (`modal_push`/`modal_pop`/`modal_replace`/`modal_close_all`) threw or rejected. The page is not crashed; surface UI feedback in the listener. |
+```js
+document.addEventListener("modal_stack:error", (event) => {
+  const { action, error } = event.detail;
+  showFlash(`Modal action ${action} failed: ${error.message}`);
+});
+```
+#### Scrollbar-width compensation
+When the first layer is pushed, `BrowserRuntime#lockScroll` measures
+`window.innerWidth - documentElement.clientWidth` and writes the result
+to `--modal-stack-scrollbar-width` on `<html>`. The shipped CSS presets
+already consume the variable (`padding-right: var(--modal-stack-scrollbar-width, 0)`)
+so fixed elements don't jump rightward on lock. If you maintain custom
+CSS, compose your fixed-position rules against the same variable.
 ### Capybara helpers
 For system specs, opt in by requiring the RSpec entrypoint:

data/app/assets/javascripts/modal_stack.js CHANGED Viewed

@@ -11,6 +11,16 @@ var VARIANTS = Object.freeze([
 var SNAPSHOT_VERSION = 1;
 var DEFAULT_MAX_AGE_MS = 30 * 60 * 1000;
 var DRAWER_SIDES = Object.freeze(["left", "right", "top", "bottom"]);
+var MAX_DEPTH_STRATEGIES = Object.freeze(["raise", "warn", "silent"]);
+class ModalStackDepthError extends Error {
+  constructor({ maxDepth, attemptedDepth }) {
+    super(`modal_stack: cannot push past max_depth=${maxDepth} ` + `(attempted depth=${attemptedDepth})`);
+    this.name = "ModalStackDepthError";
+    this.maxDepth = maxDepth;
+    this.attemptedDepth = attemptedDepth;
+  }
+}
 function normalizeLayerOptions({ variant, size, side, width, height }) {
   const normalizedSide = variant === "drawer" ? side ?? "right" : side ?? null;
   if (variant === "drawer" && !DRAWER_SIDES.includes(normalizedSide)) {
@@ -46,7 +56,7 @@ function createStack({ stackId, baseUrl }) {
 function topLayer(state) {
   return state.layers[state.layers.length - 1] ?? null;
 }
-function push(state, layer) {
+function push(state, layer, options = {}) {
   if (!layer?.id)
     throw new Error("layer.id required");
   if (!layer?.url)
@@ -55,6 +65,22 @@ function push(state, layer) {
   if (!VARIANTS.includes(variant)) {
     throw new Error(`unknown variant: ${variant}`);
   }
+  const { maxDepth = null, maxDepthStrategy = "warn" } = options;
+  if (maxDepth != null && state.layers.length >= maxDepth) {
+    if (!MAX_DEPTH_STRATEGIES.includes(maxDepthStrategy)) {
+      throw new Error(`unknown maxDepthStrategy: ${maxDepthStrategy} (expected one of ${MAX_DEPTH_STRATEGIES.join(", ")})`);
+    }
+    if (maxDepthStrategy === "raise") {
+      throw new ModalStackDepthError({
+        maxDepth,
+        attemptedDepth: state.layers.length + 1
+      });
+    }
+    if (maxDepthStrategy === "warn" && typeof console !== "undefined") {
+      console.warn(`[modal_stack] push ignored: stack is at max_depth=${maxDepth}. ` + `Set ModalStack.configuration.max_depth higher, or use ` + `max_depth_strategy = :silent to suppress this warning.`);
+    }
+    return { state, commands: [] };
+  }
   const newLayer = freezeLayer({
     id: layer.id,
     url: layer.url,
@@ -302,10 +328,19 @@ function restore(serialized, { stackId, maxAgeMs = DEFAULT_MAX_AGE_MS, now = Dat
 // app/javascript/modal_stack/orchestrator.js
 class Orchestrator {
   #expectedPopstates = 0;
-  constructor({ runtime, stackId, baseUrl, restoreFrom = null }) {
+  constructor({
+    runtime,
+    stackId,
+    baseUrl,
+    restoreFrom = null,
+    maxDepth = null,
+    maxDepthStrategy = "warn"
+  }) {
     if (!runtime)
       throw new Error("runtime required");
     this.runtime = runtime;
+    this.maxDepth = maxDepth;
+    this.maxDepthStrategy = maxDepthStrategy;
     this.state = createStack({ stackId, baseUrl });
     if (restoreFrom) {
       const restored = restore(restoreFrom, { stackId });
@@ -320,10 +355,16 @@ class Orchestrator {
     return this.state.layers.length;
   }
   async push(layer, { html = null, fragment = null } = {}) {
+    const transition = push(this.state, layer, {
+      maxDepth: this.maxDepth,
+      maxDepthStrategy: this.maxDepthStrategy
+    });
+    if (transition.commands.length === 0)
+      return;
     if (fragment == null && html == null && layer?.url) {
       fragment = await this.#prefetch(layer.url);
     }
-    return this.#dispatch(push(this.state, layer), { html, fragment });
+    return this.#dispatch(transition, { html, fragment });
   }
   pop() {
     return this.#dispatch(pop(this.state));
@@ -371,7 +412,8 @@ class Orchestrator {
     }
     const handler = this.runtime[cmd.type];
     if (typeof handler !== "function") {
-      throw new Error(`runtime missing handler for "${cmd.type}"`);
+      const known = Object.getOwnPropertyNames(Object.getPrototypeOf(this.runtime)).filter((name) => name !== "constructor" && typeof this.runtime[name] === "function").sort().join(", ");
+      throw new Error(`[modal_stack] runtime missing handler for "${cmd.type}" ` + `(stack depth=${this.depth}). ` + `Known handlers: ${known || "<none>"}.`);
     }
     await handler.call(this.runtime, cmd);
   }
@@ -380,6 +422,7 @@ class Orchestrator {
 // app/javascript/modal_stack/runtime.js
 var SNAPSHOT_KEY = "modalStackSnapshot";
 var FRAGMENT_HEADER = "X-Modal-Stack-Request";
+var SCROLLBAR_WIDTH_VAR = "--modal-stack-scrollbar-width";
 var LAYER_SELECTOR = '[data-modal-stack-target="layer"]';
 var LEAVE_TIMEOUT_MS = 600;
@@ -414,12 +457,22 @@ class BrowserRuntime {
       this.dialog.close();
   }
   lockScroll() {
-    if (this.body)
-      this.body.dataset.modalStackLocked = "";
+    if (!this.body)
+      return;
+    const root = this.document?.documentElement;
+    if (root) {
+      const scrollbarWidth = Math.max(0, (globalThis.innerWidth ?? root.clientWidth) - root.clientWidth);
+      root.style.setProperty(SCROLLBAR_WIDTH_VAR, `${scrollbarWidth}px`);
+    }
+    this.body.dataset.modalStackLocked = "";
   }
   unlockScroll() {
-    if (this.body)
-      delete this.body.dataset.modalStackLocked;
+    if (!this.body)
+      return;
+    delete this.body.dataset.modalStackLocked;
+    const root = this.document?.documentElement;
+    if (root)
+      root.style.removeProperty(SCROLLBAR_WIDTH_VAR);
   }
   inertLayer({ layerId, value }) {
     const layer = this.#findLayer(layerId);
@@ -582,7 +635,9 @@ function escapeAttr(value) {
 class ModalStackController extends Controller {
   static values = {
     stackId: String,
-    baseUrl: String
+    baseUrl: String,
+    maxDepth: { type: Number, default: 0 },
+    maxDepthStrategy: { type: String, default: "warn" }
   };
   connect() {
     const stackId = this.stackIdValue || generateLayerId();
@@ -593,7 +648,9 @@ class ModalStackController extends Controller {
       runtime: this.runtime,
       stackId,
       baseUrl,
-      restoreFrom: snapshot2
+      restoreFrom: snapshot2,
+      maxDepth: this.maxDepthValue > 0 ? this.maxDepthValue : null,
+      maxDepthStrategy: this.maxDepthStrategyValue || "warn"
     });
     this._onPopstate = (event) => this.orchestrator.onPopstate({
       historyState: event.state,
@@ -649,25 +706,46 @@ class ModalStackController extends Controller {
     }
     const StreamActions = Turbo.StreamActions || (Turbo.StreamActions = {});
     const orchestrator = this.orchestrator;
-    StreamActions.modal_push = function modalPush() {
-      orchestrator.push(layerFromStreamElement(this), {
+    const dialog = this.element;
+    const guarded = (action, fn) => function guardedStreamAction() {
+      try {
+        const result = fn.call(this, orchestrator);
+        if (result && typeof result.catch === "function") {
+          result.catch((err) => emitStreamError(dialog, action, err));
+        }
+      } catch (err) {
+        emitStreamError(dialog, action, err);
+      }
+    };
+    StreamActions.modal_push = guarded("modal_push", function(orch) {
+      return orch.push(layerFromStreamElement(this), {
         fragment: this.templateContent.cloneNode(true)
       });
-    };
-    StreamActions.modal_pop = function modalPop() {
-      orchestrator.pop();
-    };
-    StreamActions.modal_replace = function modalReplace() {
-      orchestrator.replaceTop(layerPatchFromStreamElement(this), {
+    });
+    StreamActions.modal_pop = guarded("modal_pop", function(orch) {
+      return orch.pop();
+    });
+    StreamActions.modal_replace = guarded("modal_replace", function(orch) {
+      return orch.replaceTop(layerPatchFromStreamElement(this), {
         fragment: this.templateContent.cloneNode(true),
         historyMode: this.dataset.historyMode || "replace"
       });
-    };
-    StreamActions.modal_close_all = function modalCloseAll() {
-      orchestrator.closeAll();
-    };
+    });
+    StreamActions.modal_close_all = guarded("modal_close_all", function(orch) {
+      return orch.closeAll();
+    });
   }
 }
+function emitStreamError(dialog, action, error) {
+  if (typeof console !== "undefined" && console.error) {
+    console.error(`[modal_stack] stream action "${action}" failed:`, error);
+  }
+  dialog.dispatchEvent(new CustomEvent("modal_stack:error", {
+    bubbles: true,
+    cancelable: false,
+    detail: { action, error }
+  }));
+}
 function layerFromStreamElement(el) {
   return {
     id: el.dataset.layerId || generateLayerId(),

data/app/javascript/modal_stack/controllers/modal_stack_controller.js CHANGED Viewed

@@ -6,6 +6,8 @@ export class ModalStackController extends Controller {
   static values = {
     stackId: String,
     baseUrl: String,
+    maxDepth: { type: Number, default: 0 },
+    maxDepthStrategy: { type: String, default: "warn" },
   };
   connect() {
@@ -20,6 +22,10 @@ export class ModalStackController extends Controller {
       stackId,
       baseUrl,
       restoreFrom: snapshot,
+      // Stimulus Number values default to 0, but state.js treats null as
+      // "no cap" — so map 0/missing to null here.
+      maxDepth: this.maxDepthValue > 0 ? this.maxDepthValue : null,
+      maxDepthStrategy: this.maxDepthStrategyValue || "warn",
     });
     this._onPopstate = (event) =>
@@ -89,28 +95,57 @@ export class ModalStackController extends Controller {
     }
     const StreamActions = Turbo.StreamActions || (Turbo.StreamActions = {});
     const orchestrator = this.orchestrator;
-    StreamActions.modal_push = function modalPush() {
-      orchestrator.push(layerFromStreamElement(this), {
+    const dialog = this.element;
+    // Wraps a stream-action body so a malformed payload (bad data-*, fetch
+    // 500, etc.) doesn't bubble up and break the page. The error is logged
+    // and re-emitted as `modal_stack:error` so apps can surface UI feedback.
+    const guarded = (action, fn) =>
+      function guardedStreamAction() {
+        try {
+          const result = fn.call(this, orchestrator);
+          if (result && typeof result.catch === "function") {
+            result.catch((err) => emitStreamError(dialog, action, err));
+          }
+        } catch (err) {
+          emitStreamError(dialog, action, err);
+        }
+      };
+    StreamActions.modal_push = guarded("modal_push", function (orch) {
+      return orch.push(layerFromStreamElement(this), {
         fragment: this.templateContent.cloneNode(true),
       });
-    };
+    });
-    StreamActions.modal_pop = function modalPop() {
-      orchestrator.pop();
-    };
+    StreamActions.modal_pop = guarded("modal_pop", function (orch) {
+      return orch.pop();
+    });
-    StreamActions.modal_replace = function modalReplace() {
-      orchestrator.replaceTop(layerPatchFromStreamElement(this), {
+    StreamActions.modal_replace = guarded("modal_replace", function (orch) {
+      return orch.replaceTop(layerPatchFromStreamElement(this), {
         fragment: this.templateContent.cloneNode(true),
         historyMode: this.dataset.historyMode || "replace",
       });
-    };
+    });
-    StreamActions.modal_close_all = function modalCloseAll() {
-      orchestrator.closeAll();
-    };
+    StreamActions.modal_close_all = guarded("modal_close_all", function (orch) {
+      return orch.closeAll();
+    });
+  }
+}
+function emitStreamError(dialog, action, error) {
+  if (typeof console !== "undefined" && console.error) {
+    console.error(`[modal_stack] stream action "${action}" failed:`, error);
   }
+  dialog.dispatchEvent(
+    new CustomEvent("modal_stack:error", {
+      bubbles: true,
+      cancelable: false,
+      detail: { action, error },
+    }),
+  );
 }
 function layerFromStreamElement(el) {

data/app/javascript/modal_stack/orchestrator.js CHANGED Viewed

@@ -9,12 +9,36 @@ import {
   snapshot,
 } from "./state.js";
+/**
+ * Owns the current `Stack`, calls the pure reducer, and executes the emitted
+ * commands against an injected runtime. The only stateful piece is
+ * `#expectedPopstates`, which lets us avoid re-entering the reducer when our
+ * own `historyBack` calls fire `popstate`.
+ *
+ * @typedef {Object} OrchestratorOptions
+ * @property {object} runtime         Instance with one method per command type
+ * @property {string} stackId
+ * @property {string} baseUrl
+ * @property {string|null} [restoreFrom]   Serialized snapshot from sessionStorage
+ * @property {number|null} [maxDepth]      null disables the cap
+ * @property {"raise"|"warn"|"silent"} [maxDepthStrategy]
+ */
 export class Orchestrator {
   #expectedPopstates = 0;
-  constructor({ runtime, stackId, baseUrl, restoreFrom = null }) {
+  /** @param {OrchestratorOptions} options */
+  constructor({
+    runtime,
+    stackId,
+    baseUrl,
+    restoreFrom = null,
+    maxDepth = null,
+    maxDepthStrategy = "warn",
+  }) {
     if (!runtime) throw new Error("runtime required");
     this.runtime = runtime;
+    this.maxDepth = maxDepth;
+    this.maxDepthStrategy = maxDepthStrategy;
     this.state = createStack({ stackId, baseUrl });
     if (restoreFrom) {
@@ -31,17 +55,34 @@ export class Orchestrator {
     return this.state.layers.length;
   }
+  /**
+   * Push a layer. When `html`/`fragment` are absent, the orchestrator
+   * pre-fetches the URL so `mountLayer` is a sync DOM append (no flash).
+   * @param {Partial<import("./state.js").Layer> & { id: string, url: string }} layer
+   * @param {{ html?: string|null, fragment?: DocumentFragment|null }} [options]
+   */
   async push(layer, { html = null, fragment = null } = {}) {
+    const transition = push(this.state, layer, {
+      maxDepth: this.maxDepth,
+      maxDepthStrategy: this.maxDepthStrategy,
+    });
+    if (transition.commands.length === 0) return;
     if (fragment == null && html == null && layer?.url) {
       fragment = await this.#prefetch(layer.url);
     }
-    return this.#dispatch(push(this.state, layer), { html, fragment });
+    return this.#dispatch(transition, { html, fragment });
   }
   pop() {
     return this.#dispatch(pop(this.state));
   }
+  /**
+   * Replace (morph) the top layer.
+   * @param {Partial<import("./state.js").Layer>} patch
+   * @param {{ html?: string|null, fragment?: DocumentFragment|null, historyMode?: "push"|"replace" }} [options]
+   */
   async replaceTop(patch, { html = null, fragment = null, ...opts } = {}) {
     if (fragment == null && html == null && patch?.url) {
       fragment = await this.#prefetch(patch.url);
@@ -91,7 +132,15 @@ export class Orchestrator {
     const handler = this.runtime[cmd.type];
     if (typeof handler !== "function") {
-      throw new Error(`runtime missing handler for "${cmd.type}"`);
+      const known = Object.getOwnPropertyNames(Object.getPrototypeOf(this.runtime))
+        .filter((name) => name !== "constructor" && typeof this.runtime[name] === "function")
+        .sort()
+        .join(", ");
+      throw new Error(
+        `[modal_stack] runtime missing handler for "${cmd.type}" ` +
+          `(stack depth=${this.depth}). ` +
+          `Known handlers: ${known || "<none>"}.`,
+      );
     }
     await handler.call(this.runtime, cmd);
   }

data/app/javascript/modal_stack/orchestrator.test.js CHANGED Viewed

@@ -238,6 +238,56 @@ describe("onPopstate", () => {
     expect(rebuild).toMatchObject({ targetDepth: 2, targetLayerId: "L2" });
   });
+  test("missing handler error names known handlers", async () => {
+    const partialRuntime = {
+      // showDialog is missing on purpose so we can verify the error message.
+      mountLayer: () => {},
+      lockScroll: () => {},
+      pushHistory: () => {},
+      persistSnapshot: () => {},
+    };
+    Object.setPrototypeOf(partialRuntime, {
+      mountLayer: partialRuntime.mountLayer,
+      lockScroll: partialRuntime.lockScroll,
+      pushHistory: partialRuntime.pushHistory,
+      persistSnapshot: partialRuntime.persistSnapshot,
+    });
+    const orch = new Orchestrator({
+      runtime: partialRuntime,
+      stackId: STACK_ID,
+      baseUrl: BASE_URL,
+    });
+    let caught = null;
+    try {
+      await orch.push({ id: "L1", url: "/x" });
+    } catch (e) {
+      caught = e;
+    }
+    expect(caught).toBeInstanceOf(Error);
+    expect(caught.message).toMatch(/showDialog/);
+    expect(caught.message).toMatch(/depth=/);
+  });
+  test("max_depth strategy is threaded through to the reducer", async () => {
+    const orch = new Orchestrator({
+      runtime: recordingRuntime(),
+      stackId: STACK_ID,
+      baseUrl: BASE_URL,
+      maxDepth: 1,
+      maxDepthStrategy: "raise",
+    });
+    await orch.push({ id: "L1", url: "/x" });
+    let caught = null;
+    try {
+      await orch.push({ id: "L2", url: "/y" });
+    } catch (e) {
+      caught = e;
+    }
+    expect(caught).not.toBeNull();
+    expect(caught.name).toBe("ModalStackDepthError");
+    expect(orch.depth).toBe(1);
+  });
   test("popstate from a different stack tears down without history changes", async () => {
     await orchestrator.push({ id: "L1", url: "/x" });
     runtime._calls.length = 0;

data/app/javascript/modal_stack/runtime.js CHANGED Viewed

@@ -1,12 +1,30 @@
 export const SNAPSHOT_KEY = "modalStackSnapshot";
 export const FRAGMENT_HEADER = "X-Modal-Stack-Request";
+export const SCROLLBAR_WIDTH_VAR = "--modal-stack-scrollbar-width";
 const LAYER_SELECTOR = '[data-modal-stack-target="layer"]';
 // Hard cap: never wait longer than this for an exit transition to fire,
 // even if the host CSS forgot to transition the leaving state.
 const LEAVE_TIMEOUT_MS = 600;
+/**
+ * The only file that touches `<dialog>`, `history`, `fetch`, and
+ * `sessionStorage`. Implements one method per command type emitted by the
+ * reducer in `state.js`.
+ *
+ * Tests can swap in any object that implements the same surface (see
+ * `orchestrator.test.js` for an in-memory fake).
+ */
 export class BrowserRuntime {
+  /**
+   * @param {Object} options
+   * @param {HTMLDialogElement} options.dialog
+   * @param {HTMLElement} [options.body]
+   * @param {History} [options.history]
+   * @param {typeof fetch} [options.fetcher]
+   * @param {Storage} [options.store]
+   * @param {Document} [options.documentRef]
+   */
   constructor({
     dialog,
     body = globalThis.document?.body,
@@ -35,11 +53,27 @@ export class BrowserRuntime {
   }
   lockScroll() {
-    if (this.body) this.body.dataset.modalStackLocked = "";
+    if (!this.body) return;
+    // Compensate for the scrollbar that disappears once <body> stops
+    // overflowing — without this, fixed elements jump rightward by the
+    // scrollbar width on lock. Host CSS reads the variable via
+    // `padding-right: var(--modal-stack-scrollbar-width, 0)`.
+    const root = this.document?.documentElement;
+    if (root) {
+      const scrollbarWidth = Math.max(
+        0,
+        (globalThis.innerWidth ?? root.clientWidth) - root.clientWidth,
+      );
+      root.style.setProperty(SCROLLBAR_WIDTH_VAR, `${scrollbarWidth}px`);
+    }
+    this.body.dataset.modalStackLocked = "";
   }
   unlockScroll() {
-    if (this.body) delete this.body.dataset.modalStackLocked;
+    if (!this.body) return;
+    delete this.body.dataset.modalStackLocked;
+    const root = this.document?.documentElement;
+    if (root) root.style.removeProperty(SCROLLBAR_WIDTH_VAR);
   }
   inertLayer({ layerId, value }) {

data/app/javascript/modal_stack/runtime.test.js CHANGED Viewed

@@ -1,5 +1,10 @@
 import { describe, expect, test } from "bun:test";
-import { BrowserRuntime, FRAGMENT_HEADER, SNAPSHOT_KEY } from "./runtime.js";
+import {
+  BrowserRuntime,
+  FRAGMENT_HEADER,
+  SCROLLBAR_WIDTH_VAR,
+  SNAPSHOT_KEY,
+} from "./runtime.js";
 function fakeStore() {
   const map = new Map();
@@ -110,6 +115,70 @@ describe("history wiring", () => {
   });
 });
+describe("scroll lock", () => {
+  function fakeStyle() {
+    const props = new Map();
+    return {
+      props,
+      setProperty: (k, v) => props.set(k, v),
+      removeProperty: (k) => props.delete(k),
+    };
+  }
+  function fakeRoot({ clientWidth = 1000 } = {}) {
+    return { clientWidth, style: fakeStyle() };
+  }
+  test("lockScroll sets scrollbar-width var from window/root delta", () => {
+    const root = fakeRoot({ clientWidth: 985 });
+    const body = { dataset: {} };
+    const documentRef = { documentElement: root, body };
+    const rt = new BrowserRuntime(
+      noopRuntimeArgs({ documentRef, body }),
+    );
+    // Bun's globalThis.innerWidth is 0 by default — set it for the duration.
+    const original = globalThis.innerWidth;
+    globalThis.innerWidth = 1000;
+    try {
+      rt.lockScroll();
+    } finally {
+      globalThis.innerWidth = original;
+    }
+    expect(root.style.props.get(SCROLLBAR_WIDTH_VAR)).toBe("15px");
+    expect("modalStackLocked" in body.dataset).toBe(true);
+  });
+  test("unlockScroll clears the css variable", () => {
+    const root = fakeRoot();
+    root.style.props.set(SCROLLBAR_WIDTH_VAR, "15px");
+    const body = { dataset: { modalStackLocked: "" } };
+    const documentRef = { documentElement: root, body };
+    const rt = new BrowserRuntime(
+      noopRuntimeArgs({ documentRef, body }),
+    );
+    rt.unlockScroll();
+    expect(root.style.props.has(SCROLLBAR_WIDTH_VAR)).toBe(false);
+    expect("modalStackLocked" in body.dataset).toBe(false);
+  });
+  test("lockScroll never goes negative when there's no scrollbar", () => {
+    const root = fakeRoot({ clientWidth: 1000 });
+    const body = { dataset: {} };
+    const documentRef = { documentElement: root, body };
+    const rt = new BrowserRuntime(
+      noopRuntimeArgs({ documentRef, body }),
+    );
+    const original = globalThis.innerWidth;
+    globalThis.innerWidth = 800; // narrower than clientWidth
+    try {
+      rt.lockScroll();
+    } finally {
+      globalThis.innerWidth = original;
+    }
+    expect(root.style.props.get(SCROLLBAR_WIDTH_VAR)).toBe("0px");
+  });
+});
 describe("fetch headers", () => {
   test("sends Accept and X-Modal-Stack-Request headers", async () => {
     let captured = null;

data/app/javascript/modal_stack/state.js CHANGED Viewed

@@ -1,3 +1,27 @@
+/**
+ * @typedef {"modal" | "drawer" | "bottom_sheet" | "confirmation"} Variant
+ * @typedef {"left" | "right" | "top" | "bottom"} DrawerSide
+ * @typedef {"sm" | "md" | "lg" | "xl"} Size
+ *
+ * @typedef {Object} Layer
+ * @property {string} id        Stable layer identifier (used for inertness + DOM lookup)
+ * @property {string} url       Layer URL — also written to history
+ * @property {Variant} variant
+ * @property {boolean} dismissible
+ * @property {Size|null} size
+ * @property {DrawerSide|null} side  Required for drawers; null otherwise
+ * @property {string|null} width    Free-form CSS width (e.g. "42rem")
+ * @property {string|null} height
+ *
+ * @typedef {Object} Stack
+ * @property {string} stackId
+ * @property {string} baseUrl
+ * @property {readonly Layer[]} layers
+ *
+ * @typedef {{ type: string } & Record<string, unknown>} Command
+ * @typedef {{ state: Stack, commands: readonly Command[] }} Transition
+ */
 export const VARIANTS = Object.freeze([
   "modal",
   "drawer",
@@ -8,6 +32,25 @@ export const VARIANTS = Object.freeze([
 const SNAPSHOT_VERSION = 1;
 const DEFAULT_MAX_AGE_MS = 30 * 60 * 1000;
 const DRAWER_SIDES = Object.freeze(["left", "right", "top", "bottom"]);
+const MAX_DEPTH_STRATEGIES = Object.freeze(["raise", "warn", "silent"]);
+/**
+ * Thrown by `push()` when `maxDepth` is exceeded under the `"raise"` strategy.
+ * Caught upstream by the orchestrator's stream-action error boundary so the
+ * page doesn't blow up — but applications can also catch it directly when
+ * calling `orchestrator.push()` programmatically.
+ */
+export class ModalStackDepthError extends Error {
+  constructor({ maxDepth, attemptedDepth }) {
+    super(
+      `modal_stack: cannot push past max_depth=${maxDepth} ` +
+        `(attempted depth=${attemptedDepth})`,
+    );
+    this.name = "ModalStackDepthError";
+    this.maxDepth = maxDepth;
+    this.attemptedDepth = attemptedDepth;
+  }
+}
 function normalizeLayerOptions({ variant, size, side, width, height }) {
   // A drawer must always carry a side so CSS can position it.
@@ -37,17 +80,34 @@ function freezeLayer({ id, url, variant, dismissible, size, side, width, height
   });
 }
+/**
+ * Build an empty, frozen stack.
+ * @param {{ stackId: string, baseUrl: string }} options
+ * @returns {Stack}
+ */
 export function createStack({ stackId, baseUrl }) {
   if (!stackId) throw new Error("stackId required");
   if (!baseUrl) throw new Error("baseUrl required");
   return Object.freeze({ stackId, baseUrl, layers: Object.freeze([]) });
 }
+/**
+ * @param {Stack} state
+ * @returns {Layer|null}
+ */
 export function topLayer(state) {
   return state.layers[state.layers.length - 1] ?? null;
 }
-export function push(state, layer) {
+/**
+ * Push a new layer on top of the stack.
+ *
+ * @param {Stack} state
+ * @param {Partial<Layer> & { id: string, url: string }} layer
+ * @param {{ maxDepth?: number|null, maxDepthStrategy?: "raise"|"warn"|"silent" }} [options]
+ * @returns {Transition}
+ */
+export function push(state, layer, options = {}) {
   if (!layer?.id) throw new Error("layer.id required");
   if (!layer?.url) throw new Error("layer.url required");
   const variant = layer.variant ?? "modal";
@@ -55,6 +115,29 @@ export function push(state, layer) {
     throw new Error(`unknown variant: ${variant}`);
   }
+  const { maxDepth = null, maxDepthStrategy = "warn" } = options;
+  if (maxDepth != null && state.layers.length >= maxDepth) {
+    if (!MAX_DEPTH_STRATEGIES.includes(maxDepthStrategy)) {
+      throw new Error(
+        `unknown maxDepthStrategy: ${maxDepthStrategy} (expected one of ${MAX_DEPTH_STRATEGIES.join(", ")})`,
+      );
+    }
+    if (maxDepthStrategy === "raise") {
+      throw new ModalStackDepthError({
+        maxDepth,
+        attemptedDepth: state.layers.length + 1,
+      });
+    }
+    if (maxDepthStrategy === "warn" && typeof console !== "undefined") {
+      console.warn(
+        `[modal_stack] push ignored: stack is at max_depth=${maxDepth}. ` +
+          `Set ModalStack.configuration.max_depth higher, or use ` +
+          `max_depth_strategy = :silent to suppress this warning.`,
+      );
+    }
+    return { state, commands: [] };
+  }
   const newLayer = freezeLayer({
     id: layer.id,
     url: layer.url,
@@ -102,6 +185,11 @@ export function push(state, layer) {
   return { state: { ...state, layers }, commands };
 }
+/**
+ * Pop the top layer. No-op when the stack is empty.
+ * @param {Stack} state
+ * @returns {Transition}
+ */
 export function pop(state) {
   if (state.layers.length === 0) return { state, commands: [] };
@@ -122,6 +210,13 @@ export function pop(state) {
   return { state: { ...state, layers: newLayers }, commands };
 }
+/**
+ * Replace (morph) the top layer in-place.
+ * @param {Stack} state
+ * @param {Partial<Layer>} patch
+ * @param {{ historyMode?: "push"|"replace" }} [options]
+ * @returns {Transition}
+ */
 export function replaceTop(state, patch, { historyMode = "replace" } = {}) {
   if (state.layers.length === 0) {
     throw new Error("replaceTop requires at least one layer");
@@ -171,6 +266,11 @@ export function replaceTop(state, patch, { historyMode = "replace" } = {}) {
   };
 }
+/**
+ * Close every layer at once.
+ * @param {Stack} state
+ * @returns {Transition}
+ */
 export function closeAll(state) {
   if (state.layers.length === 0) return { state, commands: [] };
   const n = state.layers.length;
@@ -186,6 +286,13 @@ export function closeAll(state) {
   };
 }
+/**
+ * Reduce a browser `popstate` into a transition: pop layers, morph the top,
+ * or request a rebuild from snapshot for forward navigation.
+ * @param {Stack} state
+ * @param {{ historyState: any, locationHref: string }} options
+ * @returns {Transition}
+ */
 export function handlePopstate(state, { historyState, locationHref }) {
   const isOurs =
     historyState && historyState.stackId === state.stackId;
@@ -273,6 +380,12 @@ export function handlePopstate(state, { historyState, locationHref }) {
   return { state, commands: [] };
 }
+/**
+ * Serialize the stack for sessionStorage. Versioned + timestamped.
+ * @param {Stack} state
+ * @param {{ now?: () => number }} [options]
+ * @returns {string}
+ */
 export function snapshot(state, { now = Date.now } = {}) {
   return JSON.stringify({
     v: SNAPSHOT_VERSION,
@@ -283,6 +396,13 @@ export function snapshot(state, { now = Date.now } = {}) {
   });
 }
+/**
+ * Restore a stack from a serialized snapshot. Returns null on any validation
+ * failure (wrong stackId, expired, malformed JSON, etc.).
+ * @param {string} serialized
+ * @param {{ stackId?: string, maxAgeMs?: number, now?: () => number }} [options]
+ * @returns {Stack|null}
+ */
 export function restore(
   serialized,
   { stackId, maxAgeMs = DEFAULT_MAX_AGE_MS, now = Date.now } = {},

data/app/javascript/modal_stack/state.test.js CHANGED Viewed

@@ -1,8 +1,9 @@
-import { describe, expect, test } from "bun:test";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import {
   closeAll,
   createStack,
   handlePopstate,
+  ModalStackDepthError,
   pop,
   push,
   replaceTop,
@@ -156,6 +157,87 @@ describe("push", () => {
     ).toThrow(/unknown drawer side/);
   });
+  describe("max_depth", () => {
+    let warnings = [];
+    const originalWarn = console.warn;
+    beforeEach(() => {
+      warnings = [];
+      console.warn = (...args) => warnings.push(args.join(" "));
+    });
+    afterEach(() => {
+      console.warn = originalWarn;
+    });
+    function stackOfDepth(n) {
+      let s = freshStack();
+      for (let i = 0; i < n; i++) {
+        s = push(s, { id: `L${i}`, url: `/p/${i}`, variant: "modal" }).state;
+      }
+      return s;
+    }
+    test("no cap when maxDepth is null (default)", () => {
+      const s = stackOfDepth(10);
+      const { state, commands } = push(s, { id: "L10", url: "/p/10", variant: "modal" });
+      expect(state.layers).toHaveLength(11);
+      expect(commands.length).toBeGreaterThan(0);
+    });
+    test("strategy 'warn' drops the push and logs", () => {
+      const s = stackOfDepth(3);
+      const { state, commands } = push(
+        s,
+        { id: "Lx", url: "/x", variant: "modal" },
+        { maxDepth: 3, maxDepthStrategy: "warn" },
+      );
+      expect(state).toBe(s);
+      expect(commands).toEqual([]);
+      expect(warnings.join("\n")).toMatch(/max_depth=3/);
+    });
+    test("strategy 'silent' drops the push without warning", () => {
+      const s = stackOfDepth(3);
+      const { state, commands } = push(
+        s,
+        { id: "Lx", url: "/x", variant: "modal" },
+        { maxDepth: 3, maxDepthStrategy: "silent" },
+      );
+      expect(state).toBe(s);
+      expect(commands).toEqual([]);
+      expect(warnings).toEqual([]);
+    });
+    test("strategy 'raise' throws ModalStackDepthError", () => {
+      const s = stackOfDepth(3);
+      let caught = null;
+      try {
+        push(
+          s,
+          { id: "Lx", url: "/x", variant: "modal" },
+          { maxDepth: 3, maxDepthStrategy: "raise" },
+        );
+      } catch (e) {
+        caught = e;
+      }
+      expect(caught).toBeInstanceOf(ModalStackDepthError);
+      expect(caught.maxDepth).toBe(3);
+      expect(caught.attemptedDepth).toBe(4);
+    });
+    test("rejects unknown strategy", () => {
+      const s = stackOfDepth(3);
+      expect(() =>
+        push(
+          s,
+          { id: "Lx", url: "/x", variant: "modal" },
+          { maxDepth: 3, maxDepthStrategy: "explode" },
+        ),
+      ).toThrow(/unknown maxDepthStrategy/);
+    });
+  });
   test("passes custom width and height to mount command", () => {
     const { state, commands } = push(freshStack(), {
       id: "L1",

data/lib/generators/modal_stack/install/templates/initializer.rb CHANGED Viewed

@@ -40,9 +40,15 @@ ModalStack.configure do |config|
   # layout to "modal" — read by `modal_stack_request?`.
   config.request_header = "X-Modal-Stack-Request"
-  # Hard cap on stack depth (push past this is a runtime error).
+  # Hard cap on stack depth. Set to `nil` to disable.
   config.max_depth = 5
+  # What to do when a push would exceed `max_depth`:
+  #   :warn   — log a console warning, drop the push (default)
+  #   :raise  — throw `ModalStackDepthError` from the JS runtime
+  #   :silent — drop the push, no warning
+  config.max_depth_strategy = :warn
   # Replace `data-turbo-confirm` window.confirm with a modal_stack
   # confirmation layer (cf. RFC §15.Q7). Off by default — opt-in.
   config.replace_turbo_confirm = false

data/lib/modal_stack/configuration.rb CHANGED Viewed

@@ -15,10 +15,9 @@ module ModalStack
     ASSETS_MODES = %i[importmap jsbundling sprockets auto].freeze
     VARIANTS = %i[modal drawer bottom_sheet confirmation].freeze
     SIZES = %i[sm md lg xl].freeze
+    MAX_DEPTH_STRATEGIES = %i[raise warn silent].freeze
     attr_accessor :default_classes,
-                  :default_dismissible,
-                  :max_depth,
                   :request_header,
                   :dialog_id,
                   :stack_root_data_attribute,
@@ -28,7 +27,13 @@ module ModalStack
                   :initializer_version,
                   :silence_initializer_warning
-    attr_reader :css_provider, :assets_mode, :default_variant, :default_size
+    attr_reader :css_provider,
+                :assets_mode,
+                :default_variant,
+                :default_size,
+                :default_dismissible,
+                :max_depth,
+                :max_depth_strategy
     def initialize
       @css_provider = :tailwind
@@ -37,6 +42,7 @@ module ModalStack
       @default_size = :md
       @default_dismissible = true
       @max_depth = 5
+      @max_depth_strategy = :warn
       @request_header = "X-Modal-Stack-Request"
       @dialog_id = "modal-stack-root"
       @stack_root_data_attribute = "modal-stack"
@@ -76,6 +82,34 @@ module ModalStack
       @default_size = value
     end
+    def default_dismissible=(value)
+      raise ArgumentError, "default_dismissible must be true or false, got #{value.inspect}" unless [true, false].include?(value)
+      @default_dismissible = value
+    end
+    def max_depth=(value)
+      if value.nil?
+        @max_depth = nil
+        return
+      end
+      coerced = Integer(value, exception: false)
+      raise ArgumentError, "max_depth must be a positive integer or nil, got #{value.inspect}" if coerced.nil? || coerced < 1
+      @max_depth = coerced
+    end
+    def max_depth_strategy=(value)
+      value = value.to_sym
+      unless MAX_DEPTH_STRATEGIES.include?(value)
+        raise ArgumentError,
+              "max_depth_strategy must be one of #{MAX_DEPTH_STRATEGIES.inspect}, got #{value.inspect}"
+      end
+      @max_depth_strategy = value
+    end
     private
     def default_classes_hash

data/lib/modal_stack/helpers/modal_stack_assets_helper.rb CHANGED Viewed

@@ -26,14 +26,22 @@ module ModalStack
         config = ModalStack.configuration
         attrs = html_options.dup
         attrs[:id] ||= config.dialog_id
-        existing_data = attrs[:data] || {}
-        controllers = [existing_data[:controller], config.stack_root_data_attribute].compact.join(" ").strip
-        attrs[:data] = existing_data.merge(controller: controllers)
+        attrs[:data] = build_dialog_data(attrs[:data], config)
         content_tag(:dialog, "".html_safe, attrs)
       end
+      # Merges caller-provided data attrs with the gem-managed ones (controller,
+      # max-depth value/strategy). Caller data wins on key collision.
+      def build_dialog_data(provided, config)
+        existing = provided || {}
+        controllers = [existing[:controller], config.stack_root_data_attribute].compact.join(" ").strip
+        data = existing.merge(controller: controllers)
+        data[:modal_stack_max_depth_value] ||= config.max_depth if config.max_depth
+        data[:modal_stack_max_depth_strategy_value] ||= config.max_depth_strategy.to_s
+        data
+      end
       # Emits a no-op SafeBuffer for now — kept as a stable hook for apps
       # that prefer a single line in their layout. The actual JS loading
       # is handled by the host app's bundler / importmap.

data/lib/modal_stack/version.rb CHANGED Viewed

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 module ModalStack
-  VERSION = "0.1.1"
+  VERSION = "0.2.0"
 end

data/lib/modal_stack.rb CHANGED Viewed

@@ -14,7 +14,7 @@ module ModalStack
   # Bumped when config/initializers/modal_stack.rb gains/loses an option,
   # so apps that haven't regenerated their initializer get a one-line
   # boot warning.  Independent from the gem's VERSION.
-  INITIALIZER_VERSION = "0.1.0"
+  INITIALIZER_VERSION = "0.2.0"
   class << self
     def configuration

metadata CHANGED Viewed

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: modal_stack
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Florian Gagnaire
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-05-02 00:00:00.000000000 Z
+date: 2026-05-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: railties