@cute-widgets/base 20.0.1

package/fesm2022/cute-widgets-base-snack-bar.mjs

@@ -0,0 +1,897 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, ChangeDetectionStrategy, ViewEncapsulation, Component, Directive, inject, NgZone, ElementRef, ChangeDetectorRef, DOCUMENT, Injector, signal, afterNextRender, isDevMode, ViewChild, DestroyRef, TemplateRef, Injectable, NgModule } from '@angular/core';
+import { CuteButton } from '@cute-widgets/base/button';
+import { Subject, of } from 'rxjs';
+import { CuteLayoutControl, CuteBaseControl } from '@cute-widgets/base/abstract';
+import { BasePortalOutlet, CdkPortalOutlet, ComponentPortal, TemplatePortal } from '@angular/cdk/portal';
+import { Platform } from '@angular/cdk/platform';
+import { CuteThemeService, toTextBgCssClass } from '@cute-widgets/base/core';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { _animationsDisabled } from '@cute-widgets/base/core/animation';
+import { LiveAnnouncer } from '@angular/cdk/a11y';
+import { BreakpointObserver, Breakpoints } from '@angular/cdk/layout';
+import { Overlay, OverlayConfig } from '@angular/cdk/overlay';
+import { takeUntil } from 'rxjs/operators';
+import { CommonModule } from '@angular/common';
+
+/** Maximum number of milliseconds that can be passed into setTimeout. */
+const MAX_TIMEOUT = Math.pow(2, 31) - 1;
+/**
+ * Reference to a snack bar dispatched from the snack bar service.
+ */
+class CuteSnackBarRef {
+    constructor(containerInstance, _overlayRef) {
+        this._overlayRef = _overlayRef;
+        /** Subject for notifying the user that the snack bar has been dismissed. */
+        this._afterDismissed = new Subject();
+        /** Subject for notifying the user that the snack bar has opened and appeared. */
+        this._afterOpened = new Subject();
+        /** Subject for notifying the user that the snack bar action was called. */
+        this._onAction = new Subject();
+        /** Whether the snack bar was dismissed using the action button. */
+        this._dismissedByAction = false;
+        this.containerInstance = containerInstance;
+        containerInstance._onExit.subscribe(() => this._finishDismiss());
+    }
+    /** Dismisses the snack bar. */
+    dismiss() {
+        if (!this._afterDismissed.closed) {
+            this.containerInstance.exit();
+        }
+        clearTimeout(this._durationTimeoutId);
+    }
+    /** Marks the snackbar action clicked. */
+    dismissWithAction() {
+        if (!this._onAction.closed) {
+            this._dismissedByAction = true;
+            this._onAction.next();
+            this._onAction.complete();
+            this.dismiss();
+        }
+        clearTimeout(this._durationTimeoutId);
+    }
+    /** Dismisses the snack bar after some duration */
+    _dismissAfter(duration) {
+        // Note that we need to cap the duration to the maximum value for setTimeout, because
+        // it'll revert to 1 if somebody passes in something greater (e.g. `Infinity`). See #17234.
+        this._durationTimeoutId = setTimeout(() => this.dismiss(), Math.min(duration, MAX_TIMEOUT));
+    }
+    /** Marks the snackbar as opened */
+    _open() {
+        if (!this._afterOpened.closed) {
+            this._afterOpened.next();
+            this._afterOpened.complete();
+        }
+    }
+    /** Cleans up the DOM after closing. */
+    _finishDismiss() {
+        this._overlayRef.dispose();
+        if (!this._onAction.closed) {
+            this._onAction.complete();
+        }
+        this._afterDismissed.next({ dismissedByAction: this._dismissedByAction });
+        this._afterDismissed.complete();
+        this._dismissedByAction = false;
+    }
+    /** Gets an observable notified when the snack bar is finished closing. */
+    afterDismissed() {
+        return this._afterDismissed;
+    }
+    /** Gets an observable notified when the snack bar has opened and appeared. */
+    afterOpened() {
+        return this.containerInstance._onEnter;
+    }
+    /** Gets an observable notified when the snack bar action is called. */
+    onAction() {
+        return this._onAction;
+    }
+}
+
+/**
+ * @license Apache-2.0
+ *
+ * Copyright (c) 2025 CuteWidgets Team. All Rights Reserved.
+ *
+ * You may not use this file except in compliance with the License
+ * that can be found at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * This code is a modification of the `@angular/material` original
+ * code licensed under MIT-style License (https://angular.dev/license).
+ */
+/** Injection token that can be used to access the data that was passed in to a snack bar. */
+const CUTE_SNACK_BAR_DATA = new InjectionToken('CuteSnackBarData');
+/**
+ * Configuration used when opening a snack-bar.
+ */
+class CuteSnackBarConfig {
+    constructor() {
+        /** The politeness level for the LiveAnnouncer announcement. */
+        this.politeness = 'assertive';
+        /**
+         * Message to be announced by the LiveAnnouncer. When opening a snackbar without a custom
+         * component or template, the announcement message will default to the specified message.
+         */
+        this.announcementMessage = '';
+        /** The length of time in milliseconds to wait before automatically dismissing the snack bar. */
+        this.duration = 0;
+        /** Data being injected into the child component. */
+        this.data = null;
+        /** The horizontal position to place the snack bar. */
+        this.horizontalPosition = 'center';
+        /** The vertical position to place the snack bar. */
+        this.verticalPosition = 'bottom';
+    }
+}
+
+/**
+ * @license Apache-2.0
+ *
+ * Copyright (c) 2025 CuteWidgets Team. All Rights Reserved.
+ *
+ * You may not use this file except in compliance with the License
+ * that can be found at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * This code is a modification of the `@angular/material` original
+ * code licensed under MIT-style License (https://angular.dev/license).
+ */
+/** Directive that should be applied to the element containing the snack bar's header elements. */
+class CuteSnackBarHeader {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: CuteSnackBarHeader, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "20.3.15", type: CuteSnackBarHeader, isStandalone: true, selector: "cute-snack-bar-header", host: { classAttribute: "cute-snack-bar-header toast-header" }, ngImport: i0, template: `
+    <ng-content></ng-content>
+  `, isInline: true, styles: [".cute-snack-bar-header{display:flex}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: CuteSnackBarHeader, decorators: [{
+            type: Component,
+            args: [{ selector: 'cute-snack-bar-header', template: `
+    <ng-content></ng-content>
+  `, host: {
+                        'class': 'cute-snack-bar-header toast-header',
+                    }, encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.OnPush, styles: [".cute-snack-bar-header{display:flex}\n"] }]
+        }] });
+/** Directive that should be applied to the element containing the snack bar's body elements. */
+class CuteSnackBarBody {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: CuteSnackBarBody, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "20.3.15", type: CuteSnackBarBody, isStandalone: true, selector: "[cuteSnackBarBody]", host: { classAttribute: "cute-snack-bar-body toast-body user-select-none" }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: CuteSnackBarBody, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: `[cuteSnackBarBody]`,
+                    host: {
+                        'class': 'cute-snack-bar-body toast-body user-select-none',
+                    },
+                }]
+        }] });
+/** Directive that should be applied to the text element to be rendered in the snack bar. */
+class CuteSnackBarLabel {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: CuteSnackBarLabel, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "20.3.15", type: CuteSnackBarLabel, isStandalone: true, selector: "[cuteSnackBarLabel]", host: { classAttribute: "cute-snack-bar-label" }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: CuteSnackBarLabel, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: `[cuteSnackBarLabel]`,
+                    host: {
+                        'class': 'cute-snack-bar-label',
+                    },
+                }]
+        }] });
+/** Directive that should be applied to the element containing the snack bar's action buttons. */
+class CuteSnackBarActions {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: CuteSnackBarActions, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "20.3.15", type: CuteSnackBarActions, isStandalone: true, selector: "[cuteSnackBarActions]", host: { classAttribute: "cute-snack-bar-actions" }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: CuteSnackBarActions, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: `[cuteSnackBarActions]`,
+                    host: {
+                        'class': 'cute-snack-bar-actions',
+                    },
+                }]
+        }] });
+/** Directive that should be applied to each of the snack bar's action buttons. */
+class CuteSnackBarAction {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: CuteSnackBarAction, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "20.3.15", type: CuteSnackBarAction, isStandalone: true, selector: "[cuteSnackBarAction]", host: { classAttribute: "cute-snack-bar-action" }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: CuteSnackBarAction, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: `[cuteSnackBarAction]`,
+                    host: {
+                        'class': 'cute-snack-bar-action',
+                    },
+                }]
+        }] });
+
+/**
+ * @license Apache-2.0
+ *
+ * Copyright (c) 2025 CuteWidgets Team. All Rights Reserved.
+ *
+ * You may not use this file except in compliance with the License
+ * that can be found at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * This code is a modification of the `@angular/material` original
+ * code licensed under MIT-style License (https://angular.dev/license).
+ */
+let uniqueID = 0;
+class SimpleSnackBar extends CuteLayoutControl {
+    constructor() {
+        super();
+        this.snackBarRef = inject(CuteSnackBarRef);
+        this.data = inject(CUTE_SNACK_BAR_DATA);
+        this.config = this.snackBarRef.containerInstance.snackBarConfig;
+    }
+    generateId() {
+        return `cute-simple-snack-bar-${uniqueID++}`;
+    }
+    /** Performs the action on the snack bar. */
+    action() {
+        this.snackBarRef.dismissWithAction();
+    }
+    /** If the action button should be shown. */
+    get hasAction() {
+        return !!this.data.action;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: SimpleSnackBar, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "20.3.15", type: SimpleSnackBar, isStandalone: true, selector: "simple-snack-bar", host: { properties: { "attr.id": "id || null" }, classAttribute: "cute-simple-snack-bar" }, exportAs: ["cuteSnackBar"], usesInheritance: true, ngImport: i0, template: "<div cuteSnackBarBody>\r\n  <div cuteSnackBarLabel>\r\n    {{data.message}}\r\n  </div>\r\n</div>\r\n\r\n<div class=\"cute-simple-snack-bar__buttons\">\r\n  @if (hasAction) {\r\n    <div cuteSnackBarActions>\r\n      <button cuteSnackBarAction\r\n              cuteButton=\"flat-button\"\r\n              [color]=\"color ? color : 'secondary'\"\r\n              magnitude=\"small\"\r\n              (click)=\"action()\">\r\n        {{data.action}}\r\n      </button>\r\n    </div>\r\n  }\r\n  @if (config.dismissible) {\r\n    <button cuteSnackBarAction\r\n            cuteButton=\"close-button\"\r\n            magnitude=\"smaller\"\r\n            aria-label=\"Close\"\r\n            (click)=\"snackBarRef.dismiss()\">\r\n    </button>\r\n<!--    i18n-aria-label=\"@@SnackBar.Close\"-->\r\n  }\r\n</div>\r\n", styles: [".cute-simple-snack-bar{display:flex;position:relative;align-items:center;justify-content:space-between}.cute-simple-snack-bar .cute-simple-snack-bar__buttons{display:flex;align-items:center;gap:4px;margin-right:var(--bs-toast-padding-x)}\n"], dependencies: [{ kind: "component", type: CuteButton, selector: "button[cuteButton],             button[cute-button],             a[cuteButton],             a[cute-button],  ", exportAs: ["cuteButton"] }, { kind: "directive", type: CuteSnackBarLabel, selector: "[cuteSnackBarLabel]" }, { kind: "directive", type: CuteSnackBarActions, selector: "[cuteSnackBarActions]" }, { kind: "directive", type: CuteSnackBarAction, selector: "[cuteSnackBarAction]" }, { kind: "directive", type: CuteSnackBarBody, selector: "[cuteSnackBarBody]" }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: SimpleSnackBar, decorators: [{
+            type: Component,
+            args: [{ selector: 'simple-snack-bar', exportAs: 'cuteSnackBar', host: {
+                        'class': 'cute-simple-snack-bar',
+                        '[attr.id]': 'id || null',
+                    }, imports: [CuteButton, CuteSnackBarLabel, CuteSnackBarActions, CuteSnackBarAction, CuteSnackBarBody], encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.OnPush, template: "<div cuteSnackBarBody>\r\n  <div cuteSnackBarLabel>\r\n    {{data.message}}\r\n  </div>\r\n</div>\r\n\r\n<div class=\"cute-simple-snack-bar__buttons\">\r\n  @if (hasAction) {\r\n    <div cuteSnackBarActions>\r\n      <button cuteSnackBarAction\r\n              cuteButton=\"flat-button\"\r\n              [color]=\"color ? color : 'secondary'\"\r\n              magnitude=\"small\"\r\n              (click)=\"action()\">\r\n        {{data.action}}\r\n      </button>\r\n    </div>\r\n  }\r\n  @if (config.dismissible) {\r\n    <button cuteSnackBarAction\r\n            cuteButton=\"close-button\"\r\n            magnitude=\"smaller\"\r\n            aria-label=\"Close\"\r\n            (click)=\"snackBarRef.dismiss()\">\r\n    </button>\r\n<!--    i18n-aria-label=\"@@SnackBar.Close\"-->\r\n  }\r\n</div>\r\n", styles: [".cute-simple-snack-bar{display:flex;position:relative;align-items:center;justify-content:space-between}.cute-simple-snack-bar .cute-simple-snack-bar__buttons{display:flex;align-items:center;gap:4px;margin-right:var(--bs-toast-padding-x)}\n"] }]
+        }], ctorParameters: () => [] });
+
+/**
+ * @license Apache-2.0
+ *
+ * Copyright (c) 2025 CuteWidgets Team. All Rights Reserved.
+ *
+ * You may not use this file except in compliance with the License
+ * that can be found at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * This code is a modification of the `@angular/material` original
+ * code licensed under MIT-style License (https://angular.dev/license).
+ */
+const ENTER_ANIMATION = '_cute-snack-bar-enter';
+const EXIT_ANIMATION = '_cute-snack-bar-exit';
+let uniqueId = 0;
+/**
+ * Internal component that wraps user-provided snack bar content.
+ */
+class CuteSnackBarContainer extends BasePortalOutlet {
+    constructor() {
+        super();
+        this._ngZone = inject(NgZone);
+        this._elementRef = inject(ElementRef);
+        this._changeDetectorRef = inject(ChangeDetectorRef);
+        this._platform = inject(Platform);
+        this._animationsDisabled = _animationsDisabled();
+        this.snackBarConfig = inject(CuteSnackBarConfig);
+        this._document = inject(DOCUMENT);
+        this._themeService = inject(CuteThemeService);
+        this._trackedModals = new Set();
+        this._injector = inject(Injector);
+        /** The number of milliseconds to wait before announcing the snack bar's content. */
+        this._announceDelay = 150;
+        /** The timeout for announcing the snack bar's content. */
+        this._announceTimeoutId = 0;
+        /** Whether the component has been destroyed. */
+        this._destroyed = false;
+        /** Subject for notifying that the snack bar has announced to screen readers. */
+        this._onAnnounce = new Subject();
+        /** Subject for notifying that the snack bar has exited from view. */
+        this._onExit = new Subject();
+        /** Subject for notifying that the snack bar has finished entering the view. */
+        this._onEnter = new Subject();
+        /** The state of the snack bar animations. */
+        this._animationState = 'void';
+        /** Unique ID of the aria-live element. */
+        this._liveElementId = `cute-snack-bar-container-live-${uniqueId++}`;
+        /**
+         * Attaches a DOM portal to the snack bar container.
+         * @deprecated To be turned into a method.
+         * @breaking-change 10.0.0
+         */
+        this.attachDomPortal = (portal) => {
+            this._assertNotAttached();
+            const result = this._portalOutlet.attachDomPortal(portal);
+            this._afterPortalAttached();
+            return result;
+        };
+        const config = this.snackBarConfig;
+        // Use aria-live rather than a live role like 'alert' or 'status'
+        // because NVDA and JAWS have show inconsistent behavior with live roles.
+        if (config.politeness === 'assertive' && !config.announcementMessage) {
+            this._live = 'assertive';
+        }
+        else if (config.politeness === 'off') {
+            this._live = 'off';
+        }
+        else {
+            this._live = 'polite';
+        }
+        // Only set a role for Firefox. Set role based on aria-live because setting role="alert" implies
+        // aria-live="assertive" which may cause issues if aria-live is set to "polite" above.
+        if (this._platform.FIREFOX) {
+            if (this._live === 'polite') {
+                this._role = 'status';
+            }
+            if (this._live === 'assertive') {
+                this._role = 'alert';
+            }
+        }
+        this.isLightTheme = signal(this._themeService.isLightTheme(), ...(ngDevMode ? [{ debugName: "isLightTheme" }] : []));
+        this._themeService.change
+            .pipe(takeUntilDestroyed())
+            .subscribe(event => {
+            this.isLightTheme.set(!event.matches);
+        });
+    }
+    /** Attach a component portal as content to this snack bar container. */
+    attachComponentPortal(portal) {
+        this._assertNotAttached();
+        const result = this._portalOutlet.attachComponentPortal(portal);
+        this._afterPortalAttached();
+        return result;
+    }
+    /** Attach a template portal as content to this snack bar container. */
+    attachTemplatePortal(portal) {
+        this._assertNotAttached();
+        const result = this._portalOutlet.attachTemplatePortal(portal);
+        this._afterPortalAttached();
+        return result;
+    }
+    /** Handle end of animations, updating the state of the snackbar. */
+    onAnimationEnd(animationName) {
+        if (animationName === EXIT_ANIMATION) {
+            this._completeExit();
+        }
+        else if (animationName === ENTER_ANIMATION) {
+            clearTimeout(this._enterFallback);
+            this._ngZone.run(() => {
+                this._onEnter.next();
+                this._onEnter.complete();
+            });
+        }
+    }
+    /** Begin animation of snack bar entrance into view. */
+    enter() {
+        if (!this._destroyed) {
+            this._animationState = 'visible';
+            // _animationState lives in host bindings and `detectChanges` does not refresh host bindings
+            // so we have to call `markForCheck` to ensure the host view is refreshed eventually.
+            this._changeDetectorRef.markForCheck();
+            this._changeDetectorRef.detectChanges();
+            this._screenReaderAnnounce();
+            if (this._animationsDisabled) {
+                afterNextRender(() => {
+                    this._ngZone.run(() => queueMicrotask(() => this.onAnimationEnd(ENTER_ANIMATION)));
+                }, { injector: this._injector });
+            }
+            else {
+                clearTimeout(this._enterFallback);
+                this._enterFallback = setTimeout(() => {
+                    // The snack bar will stay invisible if it fails to animate. Add a fallback class so it
+                    // becomes visible. This can happen in some apps that do `* {animation: none !important}`.
+                    this._elementRef.nativeElement.classList.add('mat-snack-bar-fallback-visible');
+                    this.onAnimationEnd(ENTER_ANIMATION);
+                }, 200);
+            }
+        }
+    }
+    /** Begin animation of the snack bar exiting from view. */
+    exit() {
+        if (this._destroyed) {
+            return of(undefined);
+        }
+        // It's common for snack bars to be opened by random outside calls like HTTP requests or
+        // errors. Run inside the NgZone to ensure that it functions correctly.
+        this._ngZone.run(() => {
+            // Note: this one transitions to `hidden`, rather than `void`, in order to handle the case
+            // where multiple snack bars are opened in quick succession (e.g., two consecutive calls to
+            // `CuteSnackBar.open`).
+            this._animationState = 'hidden';
+            this._changeDetectorRef.markForCheck();
+            // Mark this element with an 'exit' attribute to indicate that the snackbar has
+            // been dismissed and will soon be removed from the DOM. This is used by the snackbar
+            // test harness.
+            this._elementRef.nativeElement.setAttribute('cute-exit', '');
+            // If the snack bar hasn't been announced by the time it exits, it wouldn't have been open
+            // long enough to visually read it too, so clear the timeout for announcing.
+            clearTimeout(this._announceTimeoutId);
+            if (this._animationsDisabled) {
+                afterNextRender(() => {
+                    this._ngZone.run(() => queueMicrotask(() => this.onAnimationEnd(EXIT_ANIMATION)));
+                }, { injector: this._injector });
+            }
+            else {
+                clearTimeout(this._exitFallback);
+                this._exitFallback = setTimeout(() => this.onAnimationEnd(EXIT_ANIMATION), 200);
+            }
+        });
+        return this._onExit;
+    }
+    /** Makes sure the exit callbacks have been invoked when the element is destroyed. */
+    ngOnDestroy() {
+        this._destroyed = true;
+        this._clearFromModals();
+        this._completeExit();
+    }
+    /**
+     * Removes the element in a microtask. Helps prevent errors where we end up
+     * removing an element which is in the middle of an animation.
+     */
+    _completeExit() {
+        clearTimeout(this._exitFallback);
+        queueMicrotask(() => {
+            this._onExit.next();
+            this._onExit.complete();
+        });
+    }
+    /**
+     * Called after the portal contents have been attached. Can be
+     * used to modify the DOM once it's guaranteed to be in place.
+     */
+    _afterPortalAttached() {
+        const element = this._elementRef.nativeElement;
+        const panelClasses = this.snackBarConfig.panelClass;
+        if (panelClasses) {
+            if (Array.isArray(panelClasses)) {
+                // Note that we can't use a spread here, because IE doesn't support multiple arguments.
+                panelClasses.forEach(cssClass => element.classList.add(cssClass));
+            }
+            else {
+                element.classList.add(panelClasses);
+            }
+        }
+        this._exposeToModals();
+        // Check to see if the attached component or template uses the MDC template structure,
+        // specifically the MDC label. If not, the container should apply the MDC label class to this
+        // component's label container, which will apply MDC's label styles to the attached view.
+        // if (this._label) {
+        //   const label = this._label.nativeElement;
+        //   const labelClass = 'cute-snackbar__label';
+        //   label.classList.toggle(labelClass, !label.querySelector(`.${labelClass}`));
+        // }
+    }
+    /**
+     * Some browsers won't expose the accessibility node of the live element if there is an
+     * `aria-modal` and the live element is outside of it. This method works around the issue by
+     * pointing the `aria-owns` of all modals to the live element.
+     */
+    _exposeToModals() {
+        // TODO(http://github.com/angular/components/issues/26853): consider de-duplicating this with the
+        // `LiveAnnouncer` and any other usages.
+        //
+        // Note that the selector here is limited to CDK overlays at the moment in order to reduce the
+        // section of the DOM we need to look through. This should cover all the cases we support, but
+        // the selector can be expanded if it turns out to be too narrow.
+        const id = this._liveElementId;
+        const modals = this._document.querySelectorAll('body > .cdk-overlay-container [aria-modal="true"]');
+        for (let i = 0; i < modals.length; i++) {
+            const modal = modals[i];
+            const ariaOwns = modal.getAttribute('aria-owns');
+            this._trackedModals.add(modal);
+            if (!ariaOwns) {
+                modal.setAttribute('aria-owns', id);
+            }
+            else if (ariaOwns.indexOf(id) === -1) {
+                modal.setAttribute('aria-owns', ariaOwns + ' ' + id);
+            }
+        }
+    }
+    /** Clears the references to the live element from any modals it was added to. */
+    _clearFromModals() {
+        this._trackedModals.forEach(modal => {
+            const ariaOwns = modal.getAttribute('aria-owns');
+            if (ariaOwns) {
+                const newValue = ariaOwns.replace(this._liveElementId, '').trim();
+                if (newValue.length > 0) {
+                    modal.setAttribute('aria-owns', newValue);
+                }
+                else {
+                    modal.removeAttribute('aria-owns');
+                }
+            }
+        });
+        this._trackedModals.clear();
+    }
+    /** Asserts that no content is already attached to the container. */
+    _assertNotAttached() {
+        if (this._portalOutlet.hasAttached() && isDevMode()) {
+            throw Error('Attempting to attach snack bar content after content is already attached');
+        }
+    }
+    /**
+     * Starts a timeout to move the snack bar content to the live region so screen readers will
+     * announce it.
+     */
+    _screenReaderAnnounce() {
+        if (this._announceTimeoutId) {
+            return;
+        }
+        this._ngZone.runOutsideAngular(() => {
+            this._announceTimeoutId = setTimeout(() => {
+                if (this._destroyed) {
+                    return;
+                }
+                const element = this._elementRef.nativeElement;
+                const inertElement = element.querySelector('[aria-hidden]');
+                const liveElement = element.querySelector('[aria-live]');
+                if (inertElement && liveElement) {
+                    // If an element in the snack bar content is focused before being moved
+                    // track it and restore focus after moving to the live region.
+                    let focusedElement = null;
+                    if (this._platform.isBrowser &&
+                        document.activeElement instanceof HTMLElement &&
+                        inertElement.contains(document.activeElement)) {
+                        focusedElement = document.activeElement;
+                    }
+                    inertElement.removeAttribute('aria-hidden');
+                    liveElement.appendChild(inertElement);
+                    focusedElement?.focus();
+                    this._onAnnounce.next();
+                    this._onAnnounce.complete();
+                }
+            }, this._announceDelay);
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: CuteSnackBarContainer, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "20.3.15", type: CuteSnackBarContainer, isStandalone: true, selector: "cute-snack-bar-container", host: { listeners: { "animationend": "onAnimationEnd($event.animationName)", "animationcancel": "onAnimationEnd($event.animationName)" }, properties: { "attr.data-bs-theme": "isLightTheme() ? \"dark\" : \"light\"", "class.cute-snack-bar-container-enter": "_animationState === \"visible\"", "class.cute-snack-bar-container-exit": "_animationState === \"hidden\"", "class.cute-snack-bar-container-animations-enabled": "!_animationsDisabled" }, classAttribute: "cute-snack-bar-container toast-container" }, viewQueries: [{ propertyName: "_portalOutlet", first: true, predicate: CdkPortalOutlet, descendants: true, static: true }, { propertyName: "_label", first: true, predicate: ["label"], descendants: true, static: true }], usesInheritance: true, ngImport: i0, template: "<!--\r\n   This outer label wrapper will have the class `mdc-snackbar__label` applied if\r\n   the attached template/component does not contain it.\r\n -->\r\n<!--<div class=\"cute-snack-bar-label\" #label>-->\r\n  <!-- Initially holds the snack bar content, will be empty after announcing to screen readers. -->\r\n  <div aria-hidden=\"true\">\r\n    <ng-template cdkPortalOutlet />\r\n  </div>\r\n\r\n  <!-- Will receive the snack bar content from the non-live div, move will happen a short delay after opening -->\r\n  <div\r\n       [attr.aria-live]=\"_live\"\r\n       [attr.role]=\"_role\"\r\n       [attr.id]=\"_liveElementId\">\r\n  </div>\r\n<!--</div>-->\r\n", styles: ["cute-snack-bar-container.toast-container{position:relative;box-sizing:border-box;-webkit-tap-highlight-color:rgba(0,0,0,0);margin:.5rem}.cute-snack-bar-handset cute-snack-bar-container.toast-container{width:100vw}cute-snack-bar-container.toast-container .toast{--bs-toast-color: var(--bs-body-color);--bs-toast-bg: rgba(var(--bs-body-bg-rgb), .95)}cute-snack-bar-container.toast-container .toast:has(.toast-header){flex-direction:column;align-items:normal}.cute-snack-bar-body{display:flex;flex-direction:column}.cute-snack-bar-actions{display:flex;flex-shrink:0;align-items:center;box-sizing:border-box}.cute-snack-bar-container-animations-enabled{opacity:0}.cute-snack-bar-container-animations-enabled.cute-snack-bar-fallback-visible{opacity:1}.cute-snack-bar-container-animations-enabled.cute-snack-bar-container-enter{animation:_cute-snack-bar-enter .15s cubic-bezier(0,0,.2,1) forwards}.cute-snack-bar-container-animations-enabled.cute-snack-bar-container-exit{animation:_cute-snack-bar-exit 75ms cubic-bezier(.4,0,1,1) forwards}@keyframes _cute-snack-bar-enter{0%{transform:scale(.8);opacity:0}to{transform:scale(1);opacity:.95}}@keyframes _cute-snack-bar-exit{0%{opacity:.95}to{opacity:0}}\n"], dependencies: [{ kind: "directive", type: CdkPortalOutlet, selector: "[cdkPortalOutlet]", inputs: ["cdkPortalOutlet"], outputs: ["attached"], exportAs: ["cdkPortalOutlet"] }], changeDetection: i0.ChangeDetectionStrategy.Default, encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: CuteSnackBarContainer, decorators: [{
+            type: Component,
+            args: [{ selector: 'cute-snack-bar-container', changeDetection: ChangeDetectionStrategy.Default, encapsulation: ViewEncapsulation.None, imports: [CdkPortalOutlet], host: {
+                        'class': 'cute-snack-bar-container toast-container',
+                        '[attr.data-bs-theme]': 'isLightTheme() ? "dark" : "light"',
+                        '[class.cute-snack-bar-container-enter]': '_animationState === "visible"',
+                        '[class.cute-snack-bar-container-exit]': '_animationState === "hidden"',
+                        '[class.cute-snack-bar-container-animations-enabled]': '!_animationsDisabled',
+                        '(animationend)': 'onAnimationEnd($event.animationName)',
+                        '(animationcancel)': 'onAnimationEnd($event.animationName)',
+                    }, template: "<!--\r\n   This outer label wrapper will have the class `mdc-snackbar__label` applied if\r\n   the attached template/component does not contain it.\r\n -->\r\n<!--<div class=\"cute-snack-bar-label\" #label>-->\r\n  <!-- Initially holds the snack bar content, will be empty after announcing to screen readers. -->\r\n  <div aria-hidden=\"true\">\r\n    <ng-template cdkPortalOutlet />\r\n  </div>\r\n\r\n  <!-- Will receive the snack bar content from the non-live div, move will happen a short delay after opening -->\r\n  <div\r\n       [attr.aria-live]=\"_live\"\r\n       [attr.role]=\"_role\"\r\n       [attr.id]=\"_liveElementId\">\r\n  </div>\r\n<!--</div>-->\r\n", styles: ["cute-snack-bar-container.toast-container{position:relative;box-sizing:border-box;-webkit-tap-highlight-color:rgba(0,0,0,0);margin:.5rem}.cute-snack-bar-handset cute-snack-bar-container.toast-container{width:100vw}cute-snack-bar-container.toast-container .toast{--bs-toast-color: var(--bs-body-color);--bs-toast-bg: rgba(var(--bs-body-bg-rgb), .95)}cute-snack-bar-container.toast-container .toast:has(.toast-header){flex-direction:column;align-items:normal}.cute-snack-bar-body{display:flex;flex-direction:column}.cute-snack-bar-actions{display:flex;flex-shrink:0;align-items:center;box-sizing:border-box}.cute-snack-bar-container-animations-enabled{opacity:0}.cute-snack-bar-container-animations-enabled.cute-snack-bar-fallback-visible{opacity:1}.cute-snack-bar-container-animations-enabled.cute-snack-bar-container-enter{animation:_cute-snack-bar-enter .15s cubic-bezier(0,0,.2,1) forwards}.cute-snack-bar-container-animations-enabled.cute-snack-bar-container-exit{animation:_cute-snack-bar-exit 75ms cubic-bezier(.4,0,1,1) forwards}@keyframes _cute-snack-bar-enter{0%{transform:scale(.8);opacity:0}to{transform:scale(1);opacity:.95}}@keyframes _cute-snack-bar-exit{0%{opacity:.95}to{opacity:0}}\n"] }]
+        }], ctorParameters: () => [], propDecorators: { _portalOutlet: [{
+                type: ViewChild,
+                args: [CdkPortalOutlet, { static: true }]
+            }], _label: [{
+                type: ViewChild,
+                args: ['label', { static: true }]
+            }] } });
+
+/**
+ * @license Apache-2.0
+ *
+ * Copyright (c) 2025 CuteWidgets Team. All Rights Reserved.
+ *
+ * You may not use this file except in compliance with the License
+ * that can be found at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * This code is a modification of the `@angular/material` original
+ * code licensed under MIT-style License (https://angular.dev/license).
+ */
+/** Injection token that can be used to specify the default snack bar. */
+const CUTE_SNACK_BAR_DEFAULT_OPTIONS = new InjectionToken('cute-snack-bar-default-options', {
+    providedIn: 'root',
+    factory: () => new CuteSnackBarConfig(),
+});
+/**
+ * Service to dispatch Cute snack bar messages.
+ */
+class CuteSnackBar {
+    /** Reference to the currently opened snackbar at *any* level. */
+    get _openedSnackBarRef() {
+        const parent = this._parentSnackBar;
+        return parent ? parent._openedSnackBarRef : this._snackBarRefAtThisLevel;
+    }
+    set _openedSnackBarRef(value) {
+        if (this._parentSnackBar) {
+            this._parentSnackBar._openedSnackBarRef = value;
+        }
+        else {
+            this._snackBarRefAtThisLevel = value;
+        }
+    }
+    constructor() {
+        this._live = inject(LiveAnnouncer);
+        this._injector = inject(Injector);
+        this._overlay = inject(Overlay);
+        this._breakpointObserver = inject(BreakpointObserver);
+        this._parentSnackBar = inject(CuteSnackBar, { optional: true, skipSelf: true });
+        this._defaultConfig = inject(CUTE_SNACK_BAR_DEFAULT_OPTIONS);
+        this._animationsDisabled = _animationsDisabled();
+        this._destroyRef = inject(DestroyRef);
+        /**
+         * Reference to the current snack bar in the view *at this level* (in the Angular injector tree).
+         * If there is a parent snack-bar service, all operations should delegate to that parent
+         * via `_openedSnackBarRef`.
+         */
+        this._snackBarRefAtThisLevel = null;
+        /** The component that should be rendered as the snack bar's simple component. */
+        this._simpleSnackBarComponent = SimpleSnackBar;
+        /** The container component that attaches the provided template or component. */
+        this.snackBarContainerComponent = CuteSnackBarContainer;
+        /** The CSS class to apply for handset mode. */
+        this.handsetCssClass = 'cute-snack-bar-handset';
+    }
+    /**
+     * Creates and dispatches a snack bar with a custom component for the content, removing any
+     * currently opened snack bars.
+     *
+     * @param component Component to be instantiated.
+     * @param config Extra configuration for the snack bar.
+     */
+    openFromComponent(component, config) {
+        return this._attach(component, config);
+    }
+    /**
+     * Creates and dispatches a snack bar with a custom template for the content, removing any
+     * currently opened snack bars.
+     *
+     * @param template Template to be instantiated.
+     * @param config Extra configuration for the snack bar.
+     */
+    openFromTemplate(template, config) {
+        return this._attach(template, config);
+    }
+    /**
+     * Opens a snackbar with a message and an optional action.
+     * @param message The message to show in the snackbar.
+     * @param action The label for the snackbar action.
+     * @param config Additional configuration options for the snackbar.
+     */
+    open(message, action = '', config) {
+        const _config = { ...this._defaultConfig, ...config };
+        // Since the user doesn't have access to the component, we can
+        // override the data to pass in our own message and action.
+        _config.data = { message, action };
+        // Since the snack bar has `role="alert"`, we don't
+        // want to announce the same message twice.
+        if (_config.announcementMessage === message) {
+            _config.announcementMessage = undefined;
+        }
+        return this.openFromComponent(this._simpleSnackBarComponent, _config);
+    }
+    /**
+     * Dismisses the currently visible snack bar.
+     */
+    dismiss() {
+        if (this._openedSnackBarRef) {
+            this._openedSnackBarRef.dismiss();
+        }
+    }
+    ngOnDestroy() {
+        // Only dismiss the snack bar at the current level on destroy.
+        if (this._snackBarRefAtThisLevel) {
+            this._snackBarRefAtThisLevel.dismiss();
+        }
+    }
+    /**
+     * Attaches the snack bar container component to the overlay.
+     */
+    _attachSnackBarContainer(overlayRef, config) {
+        const userInjector = config && config.viewContainerRef && config.viewContainerRef.injector;
+        const injector = Injector.create({
+            parent: userInjector || this._injector,
+            providers: [{ provide: CuteSnackBarConfig, useValue: config }],
+        });
+        const containerPortal = new ComponentPortal(this.snackBarContainerComponent, config.viewContainerRef, injector);
+        const containerRef = overlayRef.attach(containerPortal);
+        containerRef.instance.snackBarConfig = config;
+        return containerRef.instance;
+    }
+    /**
+     * Places a new component or a template as the content of the snack bar container.
+     */
+    _attach(content, userConfig) {
+        const config = { ...new CuteSnackBarConfig(), ...this._defaultConfig, ...userConfig };
+        const overlayRef = this._createOverlay(config);
+        const container = this._attachSnackBarContainer(overlayRef, config);
+        const snackBarRef = new CuteSnackBarRef(container, overlayRef);
+        let attachedElement;
+        if (content instanceof TemplateRef) {
+            const portal = new TemplatePortal(content, null, {
+                $implicit: config.data,
+                snackBarRef,
+            });
+            snackBarRef.instance = container.attachTemplatePortal(portal);
+            attachedElement = snackBarRef.instance.rootNodes[0];
+        }
+        else {
+            const injector = this._createInjector(config, snackBarRef);
+            const portal = new ComponentPortal(content, undefined, injector);
+            const contentRef = container.attachComponentPortal(portal);
+            // We can't pass this through the injector because the injector was created earlier
+            snackBarRef.instance = contentRef.instance;
+            if (snackBarRef.instance instanceof CuteBaseControl) {
+                const baseControl = snackBarRef.instance;
+                baseControl.color = config.color;
+                baseControl.gradientFill = config.gradientFill || false;
+            }
+            attachedElement = contentRef.location;
+        }
+        // CWT: Adding Bootstrap's classes dynamically
+        const cssClasses = ["toast", "show"];
+        if (config.color) {
+            //cssClasses.push("text-bg-"+config.color);
+            cssClasses.push(toTextBgCssClass(config.color));
+        }
+        if (config.gradientFill) {
+            cssClasses.push("bg-gradient");
+        }
+        addClasses(attachedElement.nativeElement, cssClasses);
+        // Subscribe to the breakpoint observer and attach the cute-snack-bar-handset class as
+        // appropriate. This class is applied to the overlay element because the overlay must expand to
+        // fill the width with the screen for full width snackbars.
+        this._breakpointObserver
+            .observe(Breakpoints.HandsetPortrait)
+            .pipe(takeUntil(overlayRef.detachments()))
+            .subscribe(state => {
+            overlayRef.overlayElement.classList.toggle(this.handsetCssClass, state.matches);
+        });
+        if (config.announcementMessage) {
+            // Wait until the snack bar contents have been announced, then deliver this message.
+            container._onAnnounce.subscribe(() => {
+                this._live.announce(config.announcementMessage, config.politeness);
+            });
+        }
+        this._animateSnackBar(snackBarRef, config);
+        this._openedSnackBarRef = snackBarRef;
+        return this._openedSnackBarRef;
+    }
+    /** Animates the old snack bar out and the new one in. */
+    _animateSnackBar(snackBarRef, config) {
+        // When the snackbar is dismissed, clear the reference to it.
+        snackBarRef.afterDismissed()
+            .pipe(takeUntilDestroyed(this._destroyRef))
+            .subscribe(() => {
+            // Clear the snackbar ref if it hasn't already been replaced by a newer snackbar.
+            if (this._openedSnackBarRef == snackBarRef) {
+                this._openedSnackBarRef = null;
+            }
+            if (config.announcementMessage) {
+                this._live.clear();
+            }
+        });
+        // If a dismiss timeout is provided, set up dismiss based on after the snackbar is opened.
+        if (config.duration && config.duration > 0) {
+            snackBarRef.afterOpened()
+                .pipe(takeUntilDestroyed(this._destroyRef))
+                .subscribe(() => snackBarRef._dismissAfter(config.duration));
+        }
+        if (this._openedSnackBarRef) {
+            // If a snack bar is already in view, dismiss it and enter the
+            // new snack bar after exit animation is complete.
+            this._openedSnackBarRef.afterDismissed()
+                .pipe(takeUntilDestroyed(this._destroyRef))
+                .subscribe(() => {
+                snackBarRef.containerInstance.enter();
+            });
+            this._openedSnackBarRef.dismiss();
+        }
+        else {
+            // If no snack bar is in view, enter the new snack bar.
+            snackBarRef.containerInstance.enter();
+        }
+    }
+    /**
+     * Creates a new overlay and places it in the correct location.
+     * @param config The user-specified snack bar config.
+     */
+    _createOverlay(config) {
+        const overlayConfig = new OverlayConfig();
+        overlayConfig.direction = config.direction;
+        let positionStrategy = this._overlay.position().global();
+        // Set horizontal position.
+        const isRtl = config.direction === 'rtl';
+        const isLeft = config.horizontalPosition === 'left' ||
+            (config.horizontalPosition === 'start' && !isRtl) ||
+            (config.horizontalPosition === 'end' && isRtl);
+        const isRight = !isLeft && config.horizontalPosition !== 'center';
+        const OFFSET = '0';
+        if (isLeft) {
+            positionStrategy.left(OFFSET);
+        }
+        else if (isRight) {
+            positionStrategy.right(OFFSET);
+        }
+        else {
+            positionStrategy.centerHorizontally();
+        }
+        // Set horizontal position.
+        if (config.verticalPosition === 'top') {
+            positionStrategy.top(OFFSET);
+        }
+        else {
+            positionStrategy.bottom(OFFSET);
+        }
+        overlayConfig.positionStrategy = positionStrategy;
+        overlayConfig.disableAnimations = this._animationsDisabled;
+        return this._overlay.create(overlayConfig);
+    }
+    /**
+     * Creates an injector to be used inside of a snack bar component.
+     * @param config Config that was used to create the snack bar.
+     * @param snackBarRef Reference to the snack bar.
+     */
+    _createInjector(config, snackBarRef) {
+        const userInjector = config && config.viewContainerRef && config.viewContainerRef.injector;
+        return Injector.create({
+            parent: userInjector || this._injector,
+            providers: [
+                { provide: CuteSnackBarRef, useValue: snackBarRef },
+                { provide: CUTE_SNACK_BAR_DATA, useValue: config.data },
+            ],
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: CuteSnackBar, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: CuteSnackBar, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: CuteSnackBar, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [] });
+function addClasses(element, classes) {
+    if (classes) {
+        if (Array.isArray(classes)) {
+            // Note that we can't use a spread here, because IE doesn't support multiple arguments.
+            classes.forEach(cssClass => element.classList.add(cssClass));
+        }
+        else {
+            element.classList.add(classes);
+        }
+    }
+}
+
+/**
+ * @license Apache-2.0
+ *
+ * Copyright (c) 2025 CuteWidgets Team. All Rights Reserved.
+ *
+ * You may not use this file except in compliance with the License
+ * that can be found at http://www.apache.org/licenses/LICENSE-2.0
+ */
+const TYPES = [
+    CuteSnackBarContainer,
+    CuteSnackBarActions,
+    CuteSnackBarAction,
+    CuteSnackBarBody,
+    CuteSnackBarHeader,
+    CuteSnackBarLabel,
+];
+class CuteSnackbarModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: CuteSnackbarModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.15", ngImport: i0, type: CuteSnackbarModule, imports: [CommonModule, SimpleSnackBar, CuteSnackBarContainer,
+            CuteSnackBarActions,
+            CuteSnackBarAction,
+            CuteSnackBarBody,
+            CuteSnackBarHeader,
+            CuteSnackBarLabel], exports: [CuteSnackBarContainer,
+            CuteSnackBarActions,
+            CuteSnackBarAction,
+            CuteSnackBarBody,
+            CuteSnackBarHeader,
+            CuteSnackBarLabel] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: CuteSnackbarModule, providers: [CuteSnackBar], imports: [CommonModule, SimpleSnackBar] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: CuteSnackbarModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule, SimpleSnackBar, ...TYPES],
+                    exports: TYPES,
+                    providers: [CuteSnackBar],
+                    declarations: [],
+                }]
+        }] });
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { CUTE_SNACK_BAR_DATA, CUTE_SNACK_BAR_DEFAULT_OPTIONS, CuteSnackBar, CuteSnackBarAction, CuteSnackBarActions, CuteSnackBarBody, CuteSnackBarConfig, CuteSnackBarContainer, CuteSnackBarHeader, CuteSnackBarLabel, CuteSnackBarRef, CuteSnackbarModule, SimpleSnackBar };
+//# sourceMappingURL=cute-widgets-base-snack-bar.mjs.map