minisnackbar 2.0.0 → 3.0.0

package/dist/minisnackbar.js

@@ -1,381 +1,434 @@
-(function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
-    typeof define === 'function' && define.amd ? define(['exports'], factory) :
-    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.Snackbar = {}));
-})(this, (function (exports) { 'use strict';
+var Snackbar = (function () {
+  'use strict';
 
-    /**
-     * MiniSnackbar - A simple vanilla JavaScript snackbar/toast library
-     *
-     * @version 2.0.0
-     * @author Shanto Islam <shantoislamdev@gmail.com>
-     * @license MIT
-     * @description A lightweight, zero-dependency snackbar library with Material Design integration
-     * @repository https://github.com/shantoislamdev/minisnackbar
-     * @homepage https://github.com/shantoislamdev/minisnackbar#readme
-     */
-    // Snackbar class
-    class Snackbar {
-        static init(options = {}) {
-            if (this._initialized)
-                return;
-            if (typeof document === 'undefined' || !document.body) {
-                console.error('Snackbar: DOM is not available');
-                return;
-            }
-            if (options.transitionDuration && typeof options.transitionDuration === 'number') {
-                this._transitionDuration = options.transitionDuration;
-            }
-            if (document.getElementById('mini-snackbar')) {
-                this._initialized = true;
-                return;
-            }
-            if (!document.getElementById('mini-snackbar-styles')) {
-                const style = document.createElement('style');
-                style.id = 'mini-snackbar-styles';
-                style.textContent = `
-        .mini-snackbar {
-          /* Positioning */
-          position: fixed;
-          z-index: 1000;
-          left: 50%;
-          bottom: 30px;
-          transform: translateX(-50%) translateY(100%);
-          
-          /* Sizing */
-          min-width: 250px;
-          max-width: 90%;
-          
-          /* Layout */
-          display: flex;
-          align-items: center;
-          justify-content: space-between;
-          gap: 8px;
-          padding: 0.875rem 1rem;
-          
-          /* Visibility */
-          visibility: hidden;
-          
-          /* Theming */
-          background-color: var(--mini-snackbar-bg, var(--md-sys-color-inverse-surface, rgba(255, 255, 255, 1)));
-          color: var(--mini-snackbar-text, var(--md-sys-color-inverse-on-surface, rgba(27, 27, 27, 1)));
-          border: var(--mini-snackbar-border, none);
-          font-family: var(--mini-snackbar-font-family, inherit);
-          font-size: 0.875rem;
-          text-align: left;
-          border-radius: var(--mini-snackbar-radius, 1rem);
-          box-shadow: var(--mini-snackbar-shadow, 0 3px 5px -1px rgba(0,0,0,.2), 0 6px 10px 0 rgba(0,0,0,.14), 0 1px 18px 0 rgba(0,0,0,.12));
-          
-          /* Animation */
-          transition: var(--mini-snackbar-transition, transform ${this._transitionDuration}ms ease-in-out);
-        }
+  const SNACKBAR_ID = 'mini-snackbar';
+  const STYLES_ID = 'mini-snackbar-styles';
+  const SNACKBAR_CLASS = 'mini-snackbar';
+  const SNACKBAR_VISIBLE_CLASS = 'show';
+  const SNACKBAR_TEXT_CLASS = 'mini-snackbar-text';
+  const SNACKBAR_ACTION_CLASS = 'mini-snackbar-action';
+  const DEFAULT_DURATION = 3000;
+  const DEFAULT_TRANSITION_DURATION = 250;
+  const QUEUE_GAP_DURATION = 200;
 
-        .mini-snackbar.show {
-          visibility: visible;
-          transform: translateX(-50%) translateY(0);
-        }
+  function createSnackbarStyles(transitionDuration) {
+      return `
+    .mini-snackbar {
+      position: fixed;
+      z-index: 1000;
+      left: 50%;
+      bottom: 30px;
+      transform: translateX(-50%) translateY(100%);
+      min-width: 250px;
+      max-width: 90%;
+      display: flex;
+      align-items: center;
+      justify-content: space-between;
+      gap: 8px;
+      padding: 0.875rem 1rem;
+      visibility: hidden;
+      background-color: var(--mini-snackbar-bg, var(--md-sys-color-inverse-surface, rgba(255, 255, 255, 1)));
+      color: var(--mini-snackbar-text, var(--md-sys-color-inverse-on-surface, rgba(27, 27, 27, 1)));
+      border: var(--mini-snackbar-border, none);
+      font-family: var(--mini-snackbar-font-family, inherit);
+      font-size: 0.875rem;
+      text-align: left;
+      border-radius: var(--mini-snackbar-radius, 1rem);
+      box-shadow: var(--mini-snackbar-shadow, 0 3px 5px -1px rgba(0,0,0,.2), 0 6px 10px 0 rgba(0,0,0,.14), 0 1px 18px 0 rgba(0,0,0,.12));
+      transition: var(--mini-snackbar-transition, transform ${transitionDuration}ms ease-in-out);
+    }
 
-        /* Material Component Action Button */
-        .mini-snackbar .mini-snackbar-action {
-          flex-shrink: 0;
-          padding: 0.5rem 1rem;
-          margin: -0.5rem -0.5rem -0.5rem 0;
-        }
+    .mini-snackbar.show {
+      visibility: visible;
+      transform: translateX(-50%) translateY(0);
+    }
 
-        /* Fallback Action Button (when Material Components unavailable) */
-        .mini-snackbar md-text-button[data-fallback] {
-          display: inline-block;
-          flex-shrink: 0;
-          padding: 0.5rem 1rem;
-          margin: -0.5rem -0.5rem -0.5rem 0;
-          border: none;
-          background: var(--mini-snackbar-btn-bg, transparent);
-          font-size: inherit;
-          font-family: inherit;
-          font-weight: 500;
-          letter-spacing: 0.0892857143em;
-          text-transform: uppercase;
-          color: var(--mini-snackbar-btn-text, inherit);
-          cursor: pointer;
-          user-select: none;
-          border-radius: var(--mini-snackbar-btn-radius, 1rem);
-          transition: opacity 0.2s ease;
-        }
+    .mini-snackbar .mini-snackbar-action {
+      flex-shrink: 0;
+      padding: 0.5rem 1rem;
+      margin: -0.5rem -0.5rem -0.5rem 0;
+    }
 
-        .mini-snackbar md-text-button[data-fallback]:hover {
-          opacity: var(--mini-snackbar-btn-hover-opacity, 0.8);
-          outline: var(--mini-snackbar-btn-hover-outline, 2px solid var(--mini-snackbar-btn-text, inherit));
-          outline-offset: var(--mini-snackbar-btn-outline-offset, 2px);
-          background-color: var(--mini-snackbar-btn-hover-bg, transparent);
-        }
+    .mini-snackbar button.mini-snackbar-action {
+      border: none;
+      background: var(--mini-snackbar-btn-bg, transparent);
+      font-size: inherit;
+      font-family: inherit;
+      font-weight: 500;
+      letter-spacing: 0.0892857143em;
+      text-transform: uppercase;
+      color: var(--mini-snackbar-btn-text, inherit);
+      cursor: pointer;
+      user-select: none;
+      border-radius: var(--mini-snackbar-btn-radius, 1rem);
+      transition: opacity 0.2s ease;
+    }
 
-        .mini-snackbar md-text-button[data-fallback]:focus {
-          outline: var(--mini-snackbar-btn-focus-outline, 2px solid var(--mini-snackbar-btn-text, inherit));
-          outline-offset: var(--mini-snackbar-btn-outline-offset, 2px);
-        }
+    .mini-snackbar button.mini-snackbar-action:hover {
+      opacity: var(--mini-snackbar-btn-hover-opacity, 0.8);
+      outline: var(--mini-snackbar-btn-hover-outline, 2px solid var(--mini-snackbar-btn-text, inherit));
+      outline-offset: var(--mini-snackbar-btn-outline-offset, 2px);
+      background-color: var(--mini-snackbar-btn-hover-bg, transparent);
+    }
 
-        /* Mobile responsive */
-        @media (max-width: 600px) {
-          .mini-snackbar {
-            bottom: 90px;
-          }
-        }
+    .mini-snackbar button.mini-snackbar-action:focus {
+      outline: var(--mini-snackbar-btn-focus-outline, 2px solid var(--mini-snackbar-btn-text, inherit));
+      outline-offset: var(--mini-snackbar-btn-outline-offset, 2px);
+    }
 
-        /* Accessibility: Reduced motion */
-        @media (prefers-reduced-motion: reduce) {
-          .mini-snackbar {
-            transition: opacity 0.15s ease;
-          }
-        }
-      `;
-                document.head.appendChild(style);
-            }
-            const snackbar = document.createElement('div');
-            snackbar.id = 'mini-snackbar';
-            snackbar.className = 'mini-snackbar';
-            snackbar.setAttribute('role', 'alert');
-            snackbar.setAttribute('aria-live', 'assertive');
-            snackbar.setAttribute('aria-atomic', 'true');
-            const snackbarText = document.createElement('span');
-            snackbarText.className = 'mini-snackbar-text';
-            snackbar.appendChild(snackbarText);
-            document.body.appendChild(snackbar);
-            this._initialized = true;
-        }
-        static destroy() {
-            this.hideCurrent();
-            this.clearQueue();
-            const snackbar = document.getElementById('mini-snackbar');
-            if (snackbar)
-                snackbar.remove();
-            const styles = document.getElementById('mini-snackbar-styles');
-            if (styles)
-                styles.remove();
-            this._state = 'idle';
-            this._isShowing = false;
-            this._currentActionHandler = null;
-            this._currentTimeout = null;
-            this._initialized = false;
-        }
-        static getTransitionDuration() {
-            const snackbar = document.getElementById('mini-snackbar');
-            if (!snackbar)
-                return this._transitionDuration;
-            try {
-                const computedStyle = window.getComputedStyle(snackbar);
-                const duration = computedStyle.transitionDuration;
-                if (duration && duration !== '0s') {
-                    const value = parseFloat(duration);
-                    return duration.includes('ms') ? value : value * 1000;
-                }
-            }
-            catch (e) {
-                console.warn('Snackbar: Could not read transition duration from CSS', e);
-            }
-            return this._transitionDuration;
-        }
-        static add(message, action = null, duration = 3000) {
-            if (!this._initialized) {
-                console.warn('Snackbar: Not initialized. Call Snackbar.init() first.');
-                return;
-            }
-            if (typeof message !== 'string' || message.trim() === '') {
-                console.warn('Snackbar: Message must be a non-empty string');
-                return;
-            }
-            if (action !== null &&
-                (typeof action !== 'object' ||
-                    typeof action.text !== 'string' ||
-                    typeof action.handler !== 'function')) {
-                console.warn('Snackbar: Action must be an object with "text" (string) and "handler" (function) properties');
-                return;
-            }
-            if (typeof duration !== 'number' || duration <= 0) {
-                console.warn('Snackbar: Duration must be a positive number');
-                return;
-            }
-            this._queue.push({ message, action, duration });
-            if (this._state === 'idle')
-                this.showNext();
-        }
-        static _cleanupAction() {
-            const snackbar = document.getElementById('mini-snackbar');
-            if (!snackbar)
-                return;
-            const actionButton = snackbar.querySelector('.mini-snackbar-action');
-            if (actionButton && this._currentActionHandler) {
-                actionButton.removeEventListener('click', this._currentActionHandler);
-                this._currentActionHandler = null;
-                actionButton.remove();
-            }
-        }
-        static _showSnackbar(message, action, duration, onHide = null) {
-            const snackbar = document.getElementById('mini-snackbar');
-            if (!snackbar) {
-                console.error('Snackbar: Snackbar element not found. Ensure init() has been called.');
-                return;
-            }
-            this._state = 'showing';
-            this._isShowing = true;
-            const snackbarText = snackbar.querySelector('.mini-snackbar-text');
-            if (snackbarText) {
-                snackbarText.textContent = message;
-            }
-            if (action) {
-                const actionButton = document.createElement('md-text-button');
-                actionButton.classList.add('mini-snackbar-action');
-                // Fallback for when Material Components are not available
-                if (customElements.get('md-text-button') === undefined) {
-                    actionButton.setAttribute('data-fallback', '');
-                }
-                actionButton.textContent = action.text;
-                this._currentActionHandler = () => {
-                    action.handler();
-                    this._hideSnackbar(onHide);
-                };
-                actionButton.addEventListener('click', this._currentActionHandler);
-                snackbar.appendChild(actionButton);
-            }
-            snackbar.classList.add('show');
-            this._currentTimeout = setTimeout(() => {
-                this._hideSnackbar(onHide);
-            }, duration);
-        }
-        static _hideSnackbar(onHide = null) {
-            if (this._currentTimeout) {
-                clearTimeout(this._currentTimeout);
-                this._currentTimeout = null;
-            }
-            this._state = 'transitioning';
-            const snackbar = document.getElementById('mini-snackbar');
-            if (snackbar) {
-                snackbar.classList.remove('show');
-            }
-            this._cleanupAction();
-            // Wait for CSS transition to complete
-            const transitionDuration = this.getTransitionDuration();
-            setTimeout(() => {
-                this._isShowing = false;
-                this._state = 'idle';
-                if (onHide)
-                    onHide();
-            }, transitionDuration);
-        }
-        static show(message, action = null, duration = 3000) {
-            if (!this._initialized) {
-                console.warn('Snackbar: Not initialized. Call Snackbar.init() first.');
-                return;
-            }
-            if (typeof message !== 'string' || message.trim() === '') {
-                console.warn('Snackbar: Message must be a non-empty string');
-                return;
-            }
-            if (action !== null &&
-                (typeof action !== 'object' ||
-                    typeof action.text !== 'string' ||
-                    typeof action.handler !== 'function')) {
-                console.warn('Snackbar: Action must be an object with "text" (string) and "handler" (function) properties');
-                return;
-            }
-            if (typeof duration !== 'number' || duration <= 0) {
-                console.warn('Snackbar: Duration must be a positive number');
-                return;
-            }
-            // Queue message if currently transitioning
-            if (this._state === 'transitioning') {
-                this.add(message, action, duration);
-                return;
-            }
-            // Interrupt current snackbar if showing
-            if (this._isShowing) {
-                this._state = 'transitioning';
-                if (this._currentTimeout) {
-                    clearTimeout(this._currentTimeout);
-                    this._currentTimeout = null;
-                }
-                const snackbar = document.getElementById('mini-snackbar');
-                if (snackbar) {
-                    snackbar.classList.remove('show');
-                }
-                this._cleanupAction();
-                const transitionDuration = this.getTransitionDuration();
-                setTimeout(() => {
-                    this._isShowing = false;
-                    this._state = 'idle';
-                    this._showSnackbar(message, action, duration);
-                }, transitionDuration);
-            }
-            else {
-                this._showSnackbar(message, action, duration);
-            }
-        }
-        static showNext() {
-            if (this._queue.length === 0) {
-                this._isShowing = false;
-                this._state = 'idle';
-                return;
-            }
-            const item = this._queue.shift();
-            if (item) {
-                const { message, action, duration } = item;
-                this._showSnackbar(message, action, duration, () => {
-                    setTimeout(() => this.showNext(), 200);
-                });
-            }
-        }
-        static clearQueue() {
-            this._queue = [];
-        }
-        static hideCurrent() {
-            if (this._isShowing && this._state !== 'transitioning') {
-                this._hideSnackbar();
-            }
-        }
-        static isInitialized() {
-            return this._initialized;
-        }
-        // Getters/setters for testing
-        static get queue() {
-            return this._queue;
-        }
-        static set queue(value) {
-            this._queue = value;
-        }
-        static get isShowing() {
-            return this._isShowing;
-        }
-        static set isShowing(value) {
-            this._isShowing = value;
-        }
-        static get currentTimeout() {
-            return this._currentTimeout;
-        }
-        static set currentTimeout(value) {
-            this._currentTimeout = value;
-        }
-        static get state() {
-            return this._state;
-        }
-        static set state(value) {
-            this._state = value;
-        }
+    @media (max-width: 600px) {
+      .mini-snackbar {
+        bottom: 90px;
+      }
     }
-    Snackbar._queue = [];
-    Snackbar._isShowing = false;
-    Snackbar._currentTimeout = null;
-    Snackbar._state = 'idle';
-    Snackbar._currentActionHandler = null;
-    Snackbar._transitionDuration = 250;
-    Snackbar._initialized = false;
-    // Make available globally in browser for UMD builds
-    if (typeof window !== 'undefined') {
-        window.Snackbar = Snackbar;
+
+    @media (prefers-reduced-motion: reduce) {
+      .mini-snackbar {
+        transition: opacity 0.15s ease;
+      }
     }
+  `;
+  }
+  function installSnackbarStyles(document, transitionDuration) {
+      const existingStyles = document.getElementById(STYLES_ID);
+      if (existingStyles)
+          return;
+      const styles = document.createElement('style');
+      styles.id = STYLES_ID;
+      styles.textContent = createSnackbarStyles(transitionDuration);
+      document.head.appendChild(styles);
+  }
+  function removeSnackbarStyles(document) {
+      document.getElementById(STYLES_ID)?.remove();
+  }
+
+  class SnackbarRenderer {
+      constructor(document) {
+          this.actionButton = null;
+          this.actionHandler = null;
+          this.document = document;
+      }
+      ensureRoot(transitionDuration) {
+          if (!this.document.body)
+              return false;
+          installSnackbarStyles(this.document, transitionDuration);
+          if (this.getRoot())
+              return true;
+          const snackbar = this.document.createElement('div');
+          snackbar.id = SNACKBAR_ID;
+          snackbar.className = SNACKBAR_CLASS;
+          snackbar.setAttribute('role', 'alert');
+          snackbar.setAttribute('aria-live', 'assertive');
+          snackbar.setAttribute('aria-atomic', 'true');
+          const text = this.document.createElement('span');
+          text.className = SNACKBAR_TEXT_CLASS;
+          snackbar.appendChild(text);
+          this.document.body.appendChild(snackbar);
+          return true;
+      }
+      destroy() {
+          this.cleanupAction();
+          this.getRoot()?.remove();
+          removeSnackbarStyles(this.document);
+      }
+      setMessage(message) {
+          const text = this.getRoot()?.querySelector(`.${SNACKBAR_TEXT_CLASS}`);
+          if (text)
+              text.textContent = message;
+      }
+      setAction(action, onClick) {
+          this.cleanupAction();
+          if (!action)
+              return;
+          const actionButton = this.createActionButton();
+          actionButton.classList.add(SNACKBAR_ACTION_CLASS);
+          actionButton.textContent = action.text;
+          this.actionHandler = onClick;
+          actionButton.addEventListener('click', this.actionHandler);
+          this.actionButton = actionButton;
+          this.getRoot()?.appendChild(actionButton);
+      }
+      show() {
+          this.getRoot()?.classList.add(SNACKBAR_VISIBLE_CLASS);
+      }
+      hide() {
+          this.getRoot()?.classList.remove(SNACKBAR_VISIBLE_CLASS);
+      }
+      cleanupAction() {
+          if (this.actionButton && this.actionHandler) {
+              this.actionButton.removeEventListener('click', this.actionHandler);
+          }
+          this.actionButton?.remove();
+          this.actionButton = null;
+          this.actionHandler = null;
+      }
+      getTransitionDuration(fallback) {
+          const snackbar = this.getRoot();
+          const view = this.document.defaultView;
+          if (!snackbar || !view)
+              return fallback;
+          try {
+              const duration = view.getComputedStyle(snackbar).transitionDuration;
+              return parseTransitionDuration(duration, fallback);
+          }
+          catch (error) {
+              console.warn('Snackbar: Could not read transition duration from CSS', error);
+              return fallback;
+          }
+      }
+      getRoot() {
+          return this.document.getElementById(SNACKBAR_ID);
+      }
+      createActionButton() {
+          const registry = this.document.defaultView?.customElements;
+          if (registry?.get('md-text-button')) {
+              return this.document.createElement('md-text-button');
+          }
+          const button = this.document.createElement('button');
+          button.type = 'button';
+          return button;
+      }
+  }
+  function parseTransitionDuration(duration, fallback) {
+      if (!duration || duration === '0s')
+          return fallback;
+      const firstDuration = duration.split(',')[0]?.trim();
+      if (!firstDuration)
+          return fallback;
+      const value = Number.parseFloat(firstDuration);
+      if (!Number.isFinite(value))
+          return fallback;
+      return firstDuration.endsWith('ms') ? value : value * 1000;
+  }
+
+  const isValidDuration = (duration) => typeof duration === 'number' && Number.isFinite(duration) && duration > 0;
+  function normalizeItem(message, action = null, duration = DEFAULT_DURATION, warn = console.warn) {
+      if (typeof message !== 'string' || message.trim() === '') {
+          warn('Snackbar: Message must be a non-empty string');
+          return null;
+      }
+      if (action !== null &&
+          (typeof action !== 'object' ||
+              typeof action.text !== 'string' ||
+              typeof action.handler !== 'function')) {
+          warn('Snackbar: Action must be an object with "text" (string) and "handler" (function) properties');
+          return null;
+      }
+      if (!isValidDuration(duration)) {
+          warn('Snackbar: Duration must be a positive number');
+          return null;
+      }
+      return {
+          message,
+          action: action,
+          duration
+      };
+  }
+  function normalizeTransitionDuration(duration, warn = console.warn) {
+      if (duration === undefined)
+          return null;
+      if (typeof duration !== 'number' || !Number.isFinite(duration) || duration < 0) {
+          warn('Snackbar: transitionDuration must be a non-negative number');
+          return null;
+      }
+      return duration;
+  }
+
+  class SnackbarController {
+      constructor() {
+          this.queue = [];
+          this.state = 'idle';
+          this.renderer = null;
+          this.displayTimer = null;
+          this.transitionTimer = null;
+          this.queueGapTimer = null;
+          this.transitionDuration = DEFAULT_TRANSITION_DURATION;
+          this.initialized = false;
+      }
+      init(options = {}) {
+          if (this.initialized)
+              return;
+          if (typeof document === 'undefined') {
+              console.error('Snackbar: DOM is not available');
+              return;
+          }
+          const transitionDuration = normalizeTransitionDuration(options.transitionDuration);
+          if (transitionDuration !== null)
+              this.transitionDuration = transitionDuration;
+          this.renderer = new SnackbarRenderer(document);
+          if (!this.renderer.ensureRoot(this.transitionDuration)) {
+              console.error('Snackbar: DOM is not available');
+              this.renderer = null;
+              return;
+          }
+          this.initialized = true;
+      }
+      destroy() {
+          this.clearTimers();
+          this.clearQueue();
+          this.renderer?.destroy();
+          this.renderer = null;
+          this.state = 'idle';
+          this.transitionDuration = DEFAULT_TRANSITION_DURATION;
+          this.initialized = false;
+      }
+      add(message, action = null, duration) {
+          if (!this.ensureInitialized())
+              return;
+          const item = normalizeItem(message, action, duration);
+          if (!item)
+              return;
+          this.queue.push(item);
+          if (this.state === 'idle')
+              this.showNext();
+      }
+      show(message, action = null, duration) {
+          if (!this.ensureInitialized())
+              return;
+          const item = normalizeItem(message, action, duration);
+          if (!item)
+              return;
+          this.clearQueue();
+          if (this.state === 'idle') {
+              this.showItem(item);
+              return;
+          }
+          if (this.state === 'transitioning') {
+              this.clearTimer('transitionTimer');
+              this.state = 'idle';
+              this.showItem(item);
+              return;
+          }
+          this.hideActiveItem(() => this.showItem(item));
+      }
+      clearQueue() {
+          this.queue = [];
+          this.clearTimer('queueGapTimer');
+      }
+      hideCurrent() {
+          if (this.state === 'showing') {
+              this.hideActiveItem(() => this.finishCurrentItem());
+          }
+      }
+      isInitialized() {
+          return this.initialized;
+      }
+      getTransitionDuration() {
+          return this.renderer?.getTransitionDuration(this.transitionDuration) ?? this.transitionDuration;
+      }
+      showNext() {
+          if (this.state !== 'idle')
+              return;
+          const item = this.queue.shift();
+          if (!item)
+              return;
+          this.showItem(item);
+      }
+      showItem(item) {
+          if (!this.renderer)
+              return;
+          this.clearTimers();
+          this.state = 'showing';
+          this.renderer.setMessage(item.message);
+          this.renderer.setAction(item.action, () => {
+              try {
+                  item.action?.handler();
+              }
+              finally {
+                  this.hideActiveItem(() => this.finishCurrentItem());
+              }
+          });
+          this.renderer.show();
+          this.displayTimer = setTimeout(() => {
+              this.hideActiveItem(() => this.finishCurrentItem());
+          }, item.duration);
+      }
+      hideActiveItem(afterHidden) {
+          if (!this.renderer || this.state === 'transitioning')
+              return;
+          this.clearTimer('displayTimer');
+          this.state = 'transitioning';
+          this.renderer.hide();
+          this.renderer.cleanupAction();
+          this.transitionTimer = setTimeout(() => {
+              this.transitionTimer = null;
+              this.state = 'idle';
+              afterHidden?.();
+          }, this.getTransitionDuration());
+      }
+      finishCurrentItem() {
+          if (this.state !== 'idle')
+              return;
+          if (this.queue.length === 0)
+              return;
+          this.clearTimer('queueGapTimer');
+          this.queueGapTimer = setTimeout(() => {
+              this.queueGapTimer = null;
+              this.showNext();
+          }, QUEUE_GAP_DURATION);
+      }
+      ensureInitialized() {
+          if (this.initialized)
+              return true;
+          console.warn('Snackbar: Not initialized. Call Snackbar.init() first.');
+          return false;
+      }
+      clearTimers() {
+          this.clearTimer('displayTimer');
+          this.clearTimer('transitionTimer');
+          this.clearTimer('queueGapTimer');
+      }
+      clearTimer(timer) {
+          const timeout = this[timer];
+          if (timeout)
+              clearTimeout(timeout);
+          this[timer] = null;
+      }
+  }
+
+  /**
+   * MiniSnackbar - A simple vanilla JavaScript snackbar/toast library
+   *
+   * @version 3.0.0
+   * @author Shanto Islam <shantoislamdev@gmail.com>
+   * @license MIT
+   * @description A lightweight, zero-dependency snackbar library with Material Design integration
+   * @repository https://github.com/shantoislamdev/minisnackbar
+   * @homepage https://github.com/shantoislamdev/minisnackbar#readme
+   */
+  const controller = new SnackbarController();
+  class Snackbar {
+      static init(options = {}) {
+          controller.init(options);
+      }
+      static destroy() {
+          controller.destroy();
+      }
+      static getTransitionDuration() {
+          return controller.getTransitionDuration();
+      }
+      static add(message, action = null, duration) {
+          controller.add(message, action, duration);
+      }
+      static show(message, action = null, duration) {
+          controller.show(message, action, duration);
+      }
+      static clearQueue() {
+          controller.clearQueue();
+      }
+      static hideCurrent() {
+          controller.hideCurrent();
+      }
+      static isInitialized() {
+          return controller.isInitialized();
+      }
+  }
 
-    exports.Snackbar = Snackbar;
-    exports.default = Snackbar;
+  if (typeof window !== 'undefined') {
+      window.Snackbar = Snackbar;
+  }
 
-    Object.defineProperty(exports, '__esModule', { value: true });
+  return Snackbar;
 
-}));
+})();
 //# sourceMappingURL=minisnackbar.js.map