mtrl 0.7.0 → 0.8.0-next.10

package/dist/components/snackbar/position.d.ts

@@ -7,7 +7,8 @@ interface PositionConfig {
     position?: SnackbarPosition;
 }
 /**
- * Adds position handling to snackbar
+ * Adds position handling to snackbar. The position is a class; the
+ * stylesheet does the rest, so nothing here touches inline styles.
  * @param {PositionConfig} config - Position configuration
  * @returns {Function} Higher-order function that adds position features
  */

package/dist/components/snackbar/queue.d.ts

@@ -1,7 +1,15 @@
 import { SnackbarQueue } from './types';
 /**
  * Creates a queue manager for snackbars
- * Ensures only one snackbar is visible at a time
+ *
+ * Ensures only one snackbar is visible at a time. Supports two behaviors when
+ * a new snackbar is added (see {@link SnackbarQueueAddOptions}):
+ * - `'queue'` (default): the snackbar waits its turn and is shown in order.
+ * - `'replace'`: the snackbar evicts whatever is currently on screen, drops any
+ *   still-pending snackbars, and shows immediately. This keeps rapid, repeated
+ *   actions snappy instead of serializing a long backlog.
+ *
+ * @param {number} gap - Delay in ms between a dismissed snackbar and the next
  * @returns {SnackbarQueue} Queue manager with add/clear methods
  */
-export declare const createSnackbarQueue: () => SnackbarQueue;
+export declare const createSnackbarQueue: (gap?: number) => SnackbarQueue;

package/dist/components/snackbar/snackbar.d.ts

@@ -5,4 +5,13 @@ import { SnackbarConfig, SnackbarComponent } from './types';
  * @returns {SnackbarComponent} Snackbar component instance
  */
 declare const createSnackbar: (config: SnackbarConfig) => SnackbarComponent;
+/**
+ * Dismisses the snackbar on screen and drops the ones still waiting.
+ *
+ * Messages belong to the thing that raised them: a drawer that closes, an
+ * account that signs out. Without this the queue outlives them, so a message
+ * about a list nobody is looking at any more stays on screen, and, because the
+ * queue shows one at a time, the next message waits behind it.
+ */
+export declare const clearSnackbars: () => void;
 export default createSnackbar;

package/dist/components/snackbar/types.d.ts

@@ -1,41 +1,33 @@
+import type { ButtonComponent } from '../button/types';
+import type { IconButtonComponent } from '../icon-button/types';
 /**
- * Available snackbar variants
+ * Where the snackbar sits along the bottom edge
  */
-export type SnackbarVariant = 'basic' | 'action';
+export type SnackbarPosition = 'center' | 'start' | 'end';
 /**
- * Snackbar visual variants
+ * Duration presets: 4 s, 10 s, or until dismissed
  */
-export declare const SNACKBAR_VARIANTS: {
-    readonly BASIC: "basic";
-    readonly ACTION: "action";
-};
+export type SnackbarDurationPreset = 'short' | 'long' | 'indefinite';
 /**
- * Available snackbar positions
+ * A preset or a number of milliseconds (0 for indefinite)
  */
-export type SnackbarPosition = 'center' | 'start' | 'end';
+export type SnackbarDuration = SnackbarDurationPreset | number;
 /**
- * Snackbar display positions
+ * Available snackbar queue behaviors
  */
-export declare const SNACKBAR_POSITIONS: {
-    readonly CENTER: "center";
-    readonly START: "start";
-    readonly END: "end";
-};
+export type SnackbarQueueBehavior = 'queue' | 'replace';
 /**
  * Snackbar visibility states
  */
 export type SnackbarState = 'visible' | 'hidden';
 /**
- * Snackbar state classes
+ * Why a snackbar closed
  */
-export declare const SNACKBAR_STATES: {
-    readonly VISIBLE: "visible";
-    readonly HIDDEN: "hidden";
-};
+export type SnackbarCloseReason = 'timeout' | 'action' | 'close-button' | 'escape' | 'api' | 'queue';
 /**
  * Available snackbar event types
  */
-export type SnackbarEventType = 'open' | 'close' | 'action';
+export type SnackbarEventType = 'open' | 'close' | 'action' | 'dismiss';
 /**
  * Snackbar event data
  * @interface SnackbarEvent
@@ -43,28 +35,41 @@ export type SnackbarEventType = 'open' | 'close' | 'action';
 export interface SnackbarEvent {
     /** The snackbar component that triggered the event */
     snackbar: SnackbarComponent;
-    /** Original DOM event if available */
+    /** Why the snackbar closed (`close` and `dismiss` events) */
+    reason?: SnackbarCloseReason;
+    /** Original DOM event if there was one */
     originalEvent: Event | null;
-    /** Function to prevent default behavior */
-    preventDefault: () => void;
-    /** Whether default behavior was prevented */
-    defaultPrevented: boolean;
 }
 /**
  * Configuration options for the snackbar component
  * @interface SnackbarConfig
  */
 export interface SnackbarConfig {
-    /** Visual variant of the snackbar */
-    variant?: SnackbarVariant;
-    /** Position of the snackbar on screen */
-    position?: SnackbarPosition;
-    /** Text message to display */
+    /** Text message to display; up to two lines */
     message: string;
-    /** Action button text (for 'action' variant) */
+    /** Label of the single text-button action, if any */
     action?: string;
-    /** Duration in milliseconds to show the snackbar (0 for indefinite) */
-    duration?: number;
+    /** Adds a close icon button */
+    dismissible?: boolean;
+    /** Accessible name of the close icon (default "Dismiss") */
+    closeLabel?: string;
+    /**
+     * How long the snackbar stays: `'short'` (4 s), `'long'` (10 s),
+     * `'indefinite'`, or milliseconds (0 for indefinite). Defaults to
+     * `'short'` without an action and `'indefinite'` with one: an actionable
+     * snackbar should not go away on its own.
+     */
+    duration?: SnackbarDuration;
+    /** Position of the snackbar along the bottom edge */
+    position?: SnackbarPosition;
+    /**
+     * How this snackbar interacts with the queue when shown.
+     * - `'queue'` (default): wait in line and show one at a time, in order.
+     * - `'replace'`: immediately dismiss the current snackbar, drop any pending
+     *   ones, and show this snackbar right away. Useful for rapid, repeated
+     *   actions where only the latest message matters.
+     */
+    queueBehavior?: SnackbarQueueBehavior;
     /** Action button callback function */
     onAction?: (event: SnackbarEvent) => void;
     /** Callback function when the snackbar opens */
@@ -93,13 +98,10 @@ export interface SnackbarComponent {
     state: SnackbarState;
     /** The action button element (if present) */
     actionButton?: HTMLElement;
+    /** The close icon button element (if present) */
+    closeButton?: HTMLElement;
     /** Timer for auto-dismissal */
     timer?: SnackbarTimer;
-    /** Position management functions */
-    position?: {
-        getPosition: () => SnackbarPosition;
-        setPosition: (position: SnackbarPosition) => BaseComponent;
-    };
     /** Displays the snackbar */
     show: () => SnackbarComponent;
     /** Hides the snackbar */
@@ -112,9 +114,9 @@ export interface SnackbarComponent {
     setAction: (text: string) => SnackbarComponent;
     /** Gets the action button text */
     getAction: () => string;
-    /** Sets the display duration */
-    setDuration: (duration: number) => SnackbarComponent;
-    /** Gets the display duration */
+    /** Sets the display duration: a preset or milliseconds (0 for indefinite) */
+    setDuration: (duration: SnackbarDuration) => SnackbarComponent;
+    /** Gets the display duration in milliseconds (0 for indefinite) */
     getDuration: () => number;
     /** Sets the snackbar position */
     setPosition: (position: SnackbarPosition) => SnackbarComponent;
@@ -128,36 +130,69 @@ export interface SnackbarComponent {
     destroy: () => void;
 }
 /**
- * Basic component with element property
+ * The component as it passes through the enhancers
  */
 export interface BaseComponent {
     element: HTMLElement;
     emit?: (event: string, data?: any) => void;
+    on?: (event: string, handler: (...args: any[]) => void) => any;
+    off?: (event: string, handler: (...args: any[]) => void) => any;
+    getClass?: (name: string) => string;
     lifecycle?: {
         destroy?: () => void;
     };
+    text?: {
+        setText: (text: string) => any;
+        getText: () => string;
+    };
+    position?: {
+        getPosition: () => SnackbarPosition;
+        setPosition: (position: SnackbarPosition) => any;
+    };
+    action?: ButtonComponent;
+    actionButton?: HTMLElement;
+    close?: IconButtonComponent;
+    closeButton?: HTMLElement;
+    timer?: SnackbarTimer;
     [key: string]: any;
 }
 /**
  * Timer interface for snackbar auto-dismissal
  */
 export interface SnackbarTimer {
+    /** Starts the countdown from the full duration */
     start: () => void;
+    /** Cancels the countdown */
     stop: () => void;
+    /** Sets the auto-dismiss duration in milliseconds (0 for none) */
+    setDuration: (duration: number) => void;
+    /** Gets the current auto-dismiss duration in milliseconds */
+    getDuration: () => number;
 }
 /**
  * Interface for snackbars managed by the queue
  */
 export interface QueuedSnackbar {
     _show: () => void;
+    /** Visually dismisses the snackbar without advancing the queue */
+    _hide?: () => void;
+    /** The snackbar's own element, so the queue can tell whether it is still on screen */
+    element?: HTMLElement;
     on: (event: string, handler: () => void) => void;
     off: (event: string, handler: () => void) => void;
 }
+/**
+ * Options controlling how a snackbar is added to the queue
+ */
+export interface SnackbarQueueAddOptions {
+    /** Behavior to apply when adding this snackbar (defaults to `'queue'`) */
+    behavior?: SnackbarQueueBehavior;
+}
 /**
  * Interface for the snackbar queue manager
  */
 export interface SnackbarQueue {
-    add: (snackbar: QueuedSnackbar) => void;
+    add: (snackbar: QueuedSnackbar, options?: SnackbarQueueAddOptions) => void;
     clear: () => void;
     getLength: () => number;
 }
@@ -169,4 +204,6 @@ export interface ApiOptions {
         destroy: () => void;
     };
     queue: SnackbarQueue;
+    /** The resolved configuration */
+    config: SnackbarConfig;
 }