@angular/material 13.0.0-next.7 → 13.0.0-next.8

package/esm2020/slider/testing/slider-harness.mjs

@@ -0,0 +1,114 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { ComponentHarness, HarnessPredicate, parallel } from '@angular/cdk/testing';
+import { coerceBooleanProperty, coerceNumberProperty } from '@angular/cdk/coercion';
+/** Harness for interacting with a standard mat-slider in tests. */
+export class MatSliderHarness extends ComponentHarness {
+    constructor() {
+        super(...arguments);
+        this._textLabel = this.locatorFor('.mat-slider-thumb-label-text');
+        this._wrapper = this.locatorFor('.mat-slider-wrapper');
+    }
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a `MatSliderHarness` that meets
+     * certain criteria.
+     * @param options Options for filtering which slider instances are considered a match.
+     * @return a `HarnessPredicate` configured with the given options.
+     */
+    static with(options = {}) {
+        return new HarnessPredicate(MatSliderHarness, options);
+    }
+    /** Gets the slider's id. */
+    async getId() {
+        const id = await (await this.host()).getAttribute('id');
+        // In case no id has been specified, the "id" property always returns
+        // an empty string. To make this method more explicit, we return null.
+        return id !== '' ? id : null;
+    }
+    /**
+     * Gets the current display value of the slider. Returns a null promise if the thumb label is
+     * disabled.
+     */
+    async getDisplayValue() {
+        const [host, textLabel] = await parallel(() => [this.host(), this._textLabel()]);
+        if (await host.hasClass('mat-slider-thumb-label-showing')) {
+            return textLabel.text();
+        }
+        return null;
+    }
+    /** Gets the current percentage value of the slider. */
+    async getPercentage() {
+        return this._calculatePercentage(await this.getValue());
+    }
+    /** Gets the current value of the slider. */
+    async getValue() {
+        return coerceNumberProperty(await (await this.host()).getAttribute('aria-valuenow'));
+    }
+    /** Gets the maximum value of the slider. */
+    async getMaxValue() {
+        return coerceNumberProperty(await (await this.host()).getAttribute('aria-valuemax'));
+    }
+    /** Gets the minimum value of the slider. */
+    async getMinValue() {
+        return coerceNumberProperty(await (await this.host()).getAttribute('aria-valuemin'));
+    }
+    /** Whether the slider is disabled. */
+    async isDisabled() {
+        const disabled = (await this.host()).getAttribute('aria-disabled');
+        return coerceBooleanProperty(await disabled);
+    }
+    /** Gets the orientation of the slider. */
+    async getOrientation() {
+        // "aria-orientation" will always be set to either "horizontal" or "vertical".
+        return (await this.host()).getAttribute('aria-orientation');
+    }
+    /**
+     * Sets the value of the slider by clicking on the slider track.
+     *
+     * Note that in rare cases the value cannot be set to the exact specified value. This
+     * can happen if not every value of the slider maps to a single pixel that could be
+     * clicked using mouse interaction. In such cases consider using the keyboard to
+     * select the given value or expand the slider's size for a better user experience.
+     */
+    async setValue(value) {
+        const [sliderEl, wrapperEl, orientation] = await parallel(() => [this.host(), this._wrapper(), this.getOrientation()]);
+        let percentage = await this._calculatePercentage(value);
+        const { height, width } = await wrapperEl.getDimensions();
+        const isVertical = orientation === 'vertical';
+        // In case the slider is inverted in LTR mode or not inverted in RTL mode,
+        // we need to invert the percentage so that the proper value is set.
+        if (await sliderEl.hasClass('mat-slider-invert-mouse-coords')) {
+            percentage = 1 - percentage;
+        }
+        // We need to round the new coordinates because creating fake DOM
+        // events will cause the coordinates to be rounded down.
+        const relativeX = isVertical ? 0 : Math.round(width * percentage);
+        const relativeY = isVertical ? Math.round(height * percentage) : 0;
+        await wrapperEl.click(relativeX, relativeY);
+    }
+    /** Focuses the slider. */
+    async focus() {
+        return (await this.host()).focus();
+    }
+    /** Blurs the slider. */
+    async blur() {
+        return (await this.host()).blur();
+    }
+    /** Whether the slider is focused. */
+    async isFocused() {
+        return (await this.host()).isFocused();
+    }
+    /** Calculates the percentage of the given value. */
+    async _calculatePercentage(value) {
+        const [min, max] = await parallel(() => [this.getMinValue(), this.getMaxValue()]);
+        return (value - min) / (max - min);
+    }
+}
+/** The selector for the host element of a `MatSlider` instance. */
+MatSliderHarness.hostSelector = '.mat-slider';
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"slider-harness.js","sourceRoot":"","sources":["../../../../../../../src/material/slider/testing/slider-harness.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {ComponentHarness, HarnessPredicate, parallel} from '@angular/cdk/testing';\nimport {coerceBooleanProperty, coerceNumberProperty} from '@angular/cdk/coercion';\nimport {SliderHarnessFilters} from './slider-harness-filters';\n\n/** Harness for interacting with a standard mat-slider in tests. */\nexport class MatSliderHarness extends ComponentHarness {\n  /** The selector for the host element of a `MatSlider` instance. */\n  static hostSelector = '.mat-slider';\n\n  /**\n   * Gets a `HarnessPredicate` that can be used to search for a `MatSliderHarness` that meets\n   * certain criteria.\n   * @param options Options for filtering which slider instances are considered a match.\n   * @return a `HarnessPredicate` configured with the given options.\n   */\n  static with(options: SliderHarnessFilters = {}): HarnessPredicate<MatSliderHarness> {\n    return new HarnessPredicate(MatSliderHarness, options);\n  }\n\n  private _textLabel = this.locatorFor('.mat-slider-thumb-label-text');\n  private _wrapper = this.locatorFor('.mat-slider-wrapper');\n\n  /** Gets the slider's id. */\n  async getId(): Promise<string|null> {\n    const id = await (await this.host()).getAttribute('id');\n    // In case no id has been specified, the \"id\" property always returns\n    // an empty string. To make this method more explicit, we return null.\n    return id !== '' ? id : null;\n  }\n\n  /**\n   * Gets the current display value of the slider. Returns a null promise if the thumb label is\n   * disabled.\n   */\n  async getDisplayValue(): Promise<string|null> {\n    const [host, textLabel] = await parallel(() => [this.host(), this._textLabel()]);\n    if (await host.hasClass('mat-slider-thumb-label-showing')) {\n      return textLabel.text();\n    }\n    return null;\n  }\n\n  /** Gets the current percentage value of the slider. */\n  async getPercentage(): Promise<number> {\n    return this._calculatePercentage(await this.getValue());\n  }\n\n  /** Gets the current value of the slider. */\n  async getValue(): Promise<number> {\n    return coerceNumberProperty(await (await this.host()).getAttribute('aria-valuenow'));\n  }\n\n  /** Gets the maximum value of the slider. */\n  async getMaxValue(): Promise<number> {\n    return coerceNumberProperty(await (await this.host()).getAttribute('aria-valuemax'));\n  }\n\n  /** Gets the minimum value of the slider. */\n  async getMinValue(): Promise<number> {\n    return coerceNumberProperty(await (await this.host()).getAttribute('aria-valuemin'));\n  }\n\n  /** Whether the slider is disabled. */\n  async isDisabled(): Promise<boolean> {\n    const disabled = (await this.host()).getAttribute('aria-disabled');\n    return coerceBooleanProperty(await disabled);\n  }\n\n  /** Gets the orientation of the slider. */\n  async getOrientation(): Promise<'horizontal'|'vertical'> {\n    // \"aria-orientation\" will always be set to either \"horizontal\" or \"vertical\".\n    return (await this.host()).getAttribute('aria-orientation') as any;\n  }\n\n  /**\n   * Sets the value of the slider by clicking on the slider track.\n   *\n   * Note that in rare cases the value cannot be set to the exact specified value. This\n   * can happen if not every value of the slider maps to a single pixel that could be\n   * clicked using mouse interaction. In such cases consider using the keyboard to\n   * select the given value or expand the slider's size for a better user experience.\n   */\n  async setValue(value: number): Promise<void> {\n    const [sliderEl, wrapperEl, orientation] =\n        await parallel(() => [this.host(), this._wrapper(), this.getOrientation()]);\n    let percentage = await this._calculatePercentage(value);\n    const {height, width} = await wrapperEl.getDimensions();\n    const isVertical = orientation === 'vertical';\n\n    // In case the slider is inverted in LTR mode or not inverted in RTL mode,\n    // we need to invert the percentage so that the proper value is set.\n    if (await sliderEl.hasClass('mat-slider-invert-mouse-coords')) {\n      percentage = 1 - percentage;\n    }\n\n    // We need to round the new coordinates because creating fake DOM\n    // events will cause the coordinates to be rounded down.\n    const relativeX = isVertical ? 0 : Math.round(width * percentage);\n    const relativeY = isVertical ? Math.round(height * percentage) : 0;\n\n    await wrapperEl.click(relativeX, relativeY);\n  }\n\n  /** Focuses the slider. */\n  async focus(): Promise<void> {\n    return (await this.host()).focus();\n  }\n\n  /** Blurs the slider. */\n  async blur(): Promise<void> {\n    return (await this.host()).blur();\n  }\n\n  /** Whether the slider is focused. */\n  async isFocused(): Promise<boolean> {\n    return (await this.host()).isFocused();\n  }\n\n  /** Calculates the percentage of the given value. */\n  private async _calculatePercentage(value: number) {\n    const [min, max] = await parallel(() => [this.getMinValue(), this.getMaxValue()]);\n    return (value - min) / (max - min);\n  }\n}\n"]}

package/esm2020/snack-bar/simple-snack-bar.mjs

@@ -0,0 +1,44 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { ChangeDetectionStrategy, Component, Inject, ViewEncapsulation } from '@angular/core';
+import { MAT_SNACK_BAR_DATA } from './snack-bar-config';
+import { MatSnackBarRef } from './snack-bar-ref';
+import * as i0 from "@angular/core";
+import * as i1 from "./snack-bar-ref";
+import * as i2 from "@angular/material/button";
+import * as i3 from "@angular/common";
+/**
+ * A component used to open as the default snack bar, matching material spec.
+ * This should only be used internally by the snack bar service.
+ */
+export class SimpleSnackBar {
+    constructor(snackBarRef, data) {
+        this.snackBarRef = snackBarRef;
+        this.data = data;
+    }
+    /** Performs the action on the snack bar. */
+    action() {
+        this.snackBarRef.dismissWithAction();
+    }
+    /** If the action button should be shown. */
+    get hasAction() {
+        return !!this.data.action;
+    }
+}
+SimpleSnackBar.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: SimpleSnackBar, deps: [{ token: i1.MatSnackBarRef }, { token: MAT_SNACK_BAR_DATA }], target: i0.ɵɵFactoryTarget.Component });
+SimpleSnackBar.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.0.0-next.15", type: SimpleSnackBar, selector: "simple-snack-bar", host: { classAttribute: "mat-simple-snackbar" }, ngImport: i0, template: "<span>{{data.message}}</span>\n<div class=\"mat-simple-snackbar-action\"  *ngIf=\"hasAction\">\n  <button mat-button (click)=\"action()\">{{data.action}}</button>\n</div>\n", styles: [".mat-simple-snackbar{display:flex;justify-content:space-between;align-items:center;line-height:20px;opacity:1}.mat-simple-snackbar-action{flex-shrink:0;margin:-8px -8px -8px 8px}.mat-simple-snackbar-action button{max-height:36px;min-width:0}[dir=rtl] .mat-simple-snackbar-action{margin-left:-8px;margin-right:8px}\n"], components: [{ type: i2.MatButton, selector: "button[mat-button], button[mat-raised-button], button[mat-icon-button],             button[mat-fab], button[mat-mini-fab], button[mat-stroked-button],             button[mat-flat-button]", inputs: ["disabled", "disableRipple", "color"], exportAs: ["matButton"] }], directives: [{ type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: SimpleSnackBar, decorators: [{
+            type: Component,
+            args: [{ selector: 'simple-snack-bar', encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.OnPush, host: {
+                        'class': 'mat-simple-snackbar',
+                    }, template: "<span>{{data.message}}</span>\n<div class=\"mat-simple-snackbar-action\"  *ngIf=\"hasAction\">\n  <button mat-button (click)=\"action()\">{{data.action}}</button>\n</div>\n", styles: [".mat-simple-snackbar{display:flex;justify-content:space-between;align-items:center;line-height:20px;opacity:1}.mat-simple-snackbar-action{flex-shrink:0;margin:-8px -8px -8px 8px}.mat-simple-snackbar-action button{max-height:36px;min-width:0}[dir=rtl] .mat-simple-snackbar-action{margin-left:-8px;margin-right:8px}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.MatSnackBarRef }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [MAT_SNACK_BAR_DATA]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/snack-bar/snack-bar-container.mjs

@@ -0,0 +1,205 @@
+import { Platform } from '@angular/cdk/platform';
+import { BasePortalOutlet, CdkPortalOutlet, } from '@angular/cdk/portal';
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, ElementRef, NgZone, ViewChild, ViewEncapsulation, } from '@angular/core';
+import { Subject } from 'rxjs';
+import { take } from 'rxjs/operators';
+import { matSnackBarAnimations } from './snack-bar-animations';
+import { MatSnackBarConfig } from './snack-bar-config';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/platform";
+import * as i2 from "./snack-bar-config";
+import * as i3 from "@angular/cdk/portal";
+/**
+ * Internal component that wraps user-provided snack bar content.
+ * @docs-private
+ */
+export class MatSnackBarContainer extends BasePortalOutlet {
+    constructor(_ngZone, _elementRef, _changeDetectorRef, _platform, 
+    /** The snack bar configuration. */
+    snackBarConfig) {
+        super();
+        this._ngZone = _ngZone;
+        this._elementRef = _elementRef;
+        this._changeDetectorRef = _changeDetectorRef;
+        this._platform = _platform;
+        this.snackBarConfig = snackBarConfig;
+        /** The number of milliseconds to wait before announcing the snack bar's content. */
+        this._announceDelay = 150;
+        /** 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';
+        /**
+         * 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();
+            this._applySnackBarClasses();
+            return this._portalOutlet.attachDomPortal(portal);
+        };
+        // Use aria-live rather than a live role like 'alert' or 'status'
+        // because NVDA and JAWS have show inconsistent behavior with live roles.
+        if (snackBarConfig.politeness === 'assertive' && !snackBarConfig.announcementMessage) {
+            this._live = 'assertive';
+        }
+        else if (snackBarConfig.politeness === 'off') {
+            this._live = 'off';
+        }
+        else {
+            this._live = 'polite';
+        }
+        // Only set 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';
+            }
+        }
+    }
+    /** Attach a component portal as content to this snack bar container. */
+    attachComponentPortal(portal) {
+        this._assertNotAttached();
+        this._applySnackBarClasses();
+        return this._portalOutlet.attachComponentPortal(portal);
+    }
+    /** Attach a template portal as content to this snack bar container. */
+    attachTemplatePortal(portal) {
+        this._assertNotAttached();
+        this._applySnackBarClasses();
+        return this._portalOutlet.attachTemplatePortal(portal);
+    }
+    /** Handle end of animations, updating the state of the snackbar. */
+    onAnimationEnd(event) {
+        const { fromState, toState } = event;
+        if ((toState === 'void' && fromState !== 'void') || toState === 'hidden') {
+            this._completeExit();
+        }
+        if (toState === 'visible') {
+            // Note: we shouldn't use `this` inside the zone callback,
+            // because it can cause a memory leak.
+            const onEnter = this._onEnter;
+            this._ngZone.run(() => {
+                onEnter.next();
+                onEnter.complete();
+            });
+        }
+    }
+    /** Begin animation of snack bar entrance into view. */
+    enter() {
+        if (!this._destroyed) {
+            this._animationState = 'visible';
+            this._changeDetectorRef.detectChanges();
+            this._screenReaderAnnounce();
+        }
+    }
+    /** Begin animation of the snack bar exiting from view. */
+    exit() {
+        // 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
+        // `MatSnackBar.open`).
+        this._animationState = 'hidden';
+        // 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('mat-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 either, so clear the timeout for announcing.
+        clearTimeout(this._announceTimeoutId);
+        return this._onExit;
+    }
+    /** Makes sure the exit callbacks have been invoked when the element is destroyed. */
+    ngOnDestroy() {
+        this._destroyed = true;
+        this._completeExit();
+    }
+    /**
+     * Waits for the zone to settle before removing the element. Helps prevent
+     * errors where we end up removing an element which is in the middle of an animation.
+     */
+    _completeExit() {
+        this._ngZone.onMicrotaskEmpty.pipe(take(1)).subscribe(() => {
+            this._onExit.next();
+            this._onExit.complete();
+        });
+    }
+    /** Applies the various positioning and user-configured CSS classes to the snack bar. */
+    _applySnackBarClasses() {
+        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);
+            }
+        }
+        if (this.snackBarConfig.horizontalPosition === 'center') {
+            element.classList.add('mat-snack-bar-center');
+        }
+        if (this.snackBarConfig.verticalPosition === 'top') {
+            element.classList.add('mat-snack-bar-top');
+        }
+    }
+    /** Asserts that no content is already attached to the container. */
+    _assertNotAttached() {
+        if (this._portalOutlet.hasAttached() && (typeof ngDevMode === 'undefined' || ngDevMode)) {
+            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) {
+            this._ngZone.runOutsideAngular(() => {
+                this._announceTimeoutId = setTimeout(() => {
+                    const inertElement = this._elementRef.nativeElement.querySelector('[aria-hidden]');
+                    const liveElement = this._elementRef.nativeElement.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);
+            });
+        }
+    }
+}
+MatSnackBarContainer.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: MatSnackBarContainer, deps: [{ token: i0.NgZone }, { token: i0.ElementRef }, { token: i0.ChangeDetectorRef }, { token: i1.Platform }, { token: i2.MatSnackBarConfig }], target: i0.ɵɵFactoryTarget.Component });
+MatSnackBarContainer.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.0.0-next.15", type: MatSnackBarContainer, selector: "snack-bar-container", host: { listeners: { "@state.done": "onAnimationEnd($event)" }, properties: { "@state": "_animationState" }, classAttribute: "mat-snack-bar-container" }, viewQueries: [{ propertyName: "_portalOutlet", first: true, predicate: CdkPortalOutlet, descendants: true, static: true }], usesInheritance: true, ngImport: i0, template: "<!-- Initially holds the snack bar content, will be empty after announcing to screen readers. -->\n<div aria-hidden=\"true\">\n  <ng-template cdkPortalOutlet></ng-template>\n</div>\n\n<!-- Will receive the snack bar content from the non-live div, move will happen a short delay after opening -->\n<div [attr.aria-live]=\"_live\" [attr.role]=\"_role\"></div>\n", styles: [".mat-snack-bar-container{border-radius:4px;box-sizing:border-box;display:block;margin:24px;max-width:33vw;min-width:344px;padding:14px 16px;min-height:48px;transform-origin:center}.cdk-high-contrast-active .mat-snack-bar-container{border:solid 1px}.mat-snack-bar-handset{width:100%}.mat-snack-bar-handset .mat-snack-bar-container{margin:8px;max-width:100%;min-width:0;width:100%}\n"], directives: [{ type: i3.CdkPortalOutlet, selector: "[cdkPortalOutlet]", inputs: ["cdkPortalOutlet"], outputs: ["attached"], exportAs: ["cdkPortalOutlet"] }], animations: [matSnackBarAnimations.snackBarState], changeDetection: i0.ChangeDetectionStrategy.Default, encapsulation: i0.ViewEncapsulation.None });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: MatSnackBarContainer, decorators: [{
+            type: Component,
+            args: [{ selector: 'snack-bar-container', changeDetection: ChangeDetectionStrategy.Default, encapsulation: ViewEncapsulation.None, animations: [matSnackBarAnimations.snackBarState], host: {
+                        'class': 'mat-snack-bar-container',
+                        '[@state]': '_animationState',
+                        '(@state.done)': 'onAnimationEnd($event)'
+                    }, template: "<!-- Initially holds the snack bar content, will be empty after announcing to screen readers. -->\n<div aria-hidden=\"true\">\n  <ng-template cdkPortalOutlet></ng-template>\n</div>\n\n<!-- Will receive the snack bar content from the non-live div, move will happen a short delay after opening -->\n<div [attr.aria-live]=\"_live\" [attr.role]=\"_role\"></div>\n", styles: [".mat-snack-bar-container{border-radius:4px;box-sizing:border-box;display:block;margin:24px;max-width:33vw;min-width:344px;padding:14px 16px;min-height:48px;transform-origin:center}.cdk-high-contrast-active .mat-snack-bar-container{border:solid 1px}.mat-snack-bar-handset{width:100%}.mat-snack-bar-handset .mat-snack-bar-container{margin:8px;max-width:100%;min-width:0;width:100%}\n"] }]
+        }], ctorParameters: function () { return [{ type: i0.NgZone }, { type: i0.ElementRef }, { type: i0.ChangeDetectorRef }, { type: i1.Platform }, { type: i2.MatSnackBarConfig }]; }, propDecorators: { _portalOutlet: [{
+                type: ViewChild,
+                args: [CdkPortalOutlet, { static: true }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"snack-bar-container.js","sourceRoot":"","sources":["../../../../../../src/material/snack-bar/snack-bar-container.ts","../../../../../../src/material/snack-bar/snack-bar-container.html"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {AnimationEvent} from '@angular/animations';\nimport {AriaLivePoliteness} from '@angular/cdk/a11y';\nimport {Platform} from '@angular/cdk/platform';\nimport {\n  BasePortalOutlet,\n  CdkPortalOutlet,\n  ComponentPortal,\n  TemplatePortal,\n  DomPortal,\n} from '@angular/cdk/portal';\nimport {\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  ComponentRef,\n  ElementRef,\n  EmbeddedViewRef,\n  NgZone,\n  OnDestroy,\n  ViewChild,\n  ViewEncapsulation,\n} from '@angular/core';\nimport {Observable, Subject} from 'rxjs';\nimport {take} from 'rxjs/operators';\nimport {matSnackBarAnimations} from './snack-bar-animations';\nimport {MatSnackBarConfig} from './snack-bar-config';\n\n/**\n * Internal interface for a snack bar container.\n * @docs-private\n */\nexport interface _SnackBarContainer {\n  snackBarConfig: MatSnackBarConfig;\n  readonly _onAnnounce: Subject<any>;\n  readonly _onExit: Subject<any>;\n  readonly _onEnter: Subject<any>;\n  enter: () => void;\n  exit: () => Observable<void>;\n  attachTemplatePortal: <C>(portal: TemplatePortal<C>) => EmbeddedViewRef<C>;\n  attachComponentPortal: <T>(portal: ComponentPortal<T>) => ComponentRef<T>;\n}\n\n/**\n * Internal component that wraps user-provided snack bar content.\n * @docs-private\n */\n@Component({\n  selector: 'snack-bar-container',\n  templateUrl: 'snack-bar-container.html',\n  styleUrls: ['snack-bar-container.css'],\n  // In Ivy embedded views will be change detected from their declaration place, rather than\n  // where they were stamped out. This means that we can't have the snack bar container be OnPush,\n  // because it might cause snack bars that were opened from a template not to be out of date.\n  // tslint:disable-next-line:validate-decorators\n  changeDetection: ChangeDetectionStrategy.Default,\n  encapsulation: ViewEncapsulation.None,\n  animations: [matSnackBarAnimations.snackBarState],\n  host: {\n    'class': 'mat-snack-bar-container',\n    '[@state]': '_animationState',\n    '(@state.done)': 'onAnimationEnd($event)'\n  },\n})\nexport class MatSnackBarContainer extends BasePortalOutlet\n    implements OnDestroy, _SnackBarContainer {\n  /** The number of milliseconds to wait before announcing the snack bar's content. */\n  private readonly _announceDelay: number = 150;\n\n  /** The timeout for announcing the snack bar's content. */\n  private _announceTimeoutId: any;\n\n  /** Whether the component has been destroyed. */\n  private _destroyed = false;\n\n  /** The portal outlet inside of this container into which the snack bar content will be loaded. */\n  @ViewChild(CdkPortalOutlet, {static: true}) _portalOutlet: CdkPortalOutlet;\n\n  /** Subject for notifying that the snack bar has announced to screen readers. */\n  readonly _onAnnounce: Subject<void> = new Subject();\n\n  /** Subject for notifying that the snack bar has exited from view. */\n  readonly _onExit: Subject<void> = new Subject();\n\n  /** Subject for notifying that the snack bar has finished entering the view. */\n  readonly _onEnter: Subject<void> = new Subject();\n\n  /** The state of the snack bar animations. */\n  _animationState = 'void';\n\n  /** aria-live value for the live region. */\n  _live: AriaLivePoliteness;\n\n  /**\n   * Role of the live region. This is only for Firefox as there is a known issue where Firefox +\n   * JAWS does not read out aria-live message.\n   */\n  _role?: 'status' | 'alert';\n\n  constructor(\n    private _ngZone: NgZone,\n    private _elementRef: ElementRef<HTMLElement>,\n    private _changeDetectorRef: ChangeDetectorRef,\n    private _platform: Platform,\n    /** The snack bar configuration. */\n    public snackBarConfig: MatSnackBarConfig) {\n\n    super();\n\n    // Use aria-live rather than a live role like 'alert' or 'status'\n    // because NVDA and JAWS have show inconsistent behavior with live roles.\n    if (snackBarConfig.politeness === 'assertive' && !snackBarConfig.announcementMessage) {\n      this._live = 'assertive';\n    } else if (snackBarConfig.politeness === 'off') {\n      this._live = 'off';\n    } else {\n      this._live = 'polite';\n    }\n\n    // Only set role for Firefox. Set role based on aria-live because setting role=\"alert\" implies\n    // aria-live=\"assertive\" which may cause issues if aria-live is set to \"polite\" above.\n    if (this._platform.FIREFOX) {\n      if (this._live === 'polite') {\n        this._role = 'status';\n      }\n      if (this._live === 'assertive') {\n        this._role = 'alert';\n      }\n    }\n  }\n\n  /** Attach a component portal as content to this snack bar container. */\n  attachComponentPortal<T>(portal: ComponentPortal<T>): ComponentRef<T> {\n    this._assertNotAttached();\n    this._applySnackBarClasses();\n    return this._portalOutlet.attachComponentPortal(portal);\n  }\n\n  /** Attach a template portal as content to this snack bar container. */\n  attachTemplatePortal<C>(portal: TemplatePortal<C>): EmbeddedViewRef<C> {\n    this._assertNotAttached();\n    this._applySnackBarClasses();\n    return this._portalOutlet.attachTemplatePortal(portal);\n  }\n\n  /**\n   * Attaches a DOM portal to the snack bar container.\n   * @deprecated To be turned into a method.\n   * @breaking-change 10.0.0\n   */\n  override attachDomPortal = (portal: DomPortal) => {\n    this._assertNotAttached();\n    this._applySnackBarClasses();\n    return this._portalOutlet.attachDomPortal(portal);\n  }\n\n  /** Handle end of animations, updating the state of the snackbar. */\n  onAnimationEnd(event: AnimationEvent) {\n    const {fromState, toState} = event;\n\n    if ((toState === 'void' && fromState !== 'void') || toState === 'hidden') {\n      this._completeExit();\n    }\n\n    if (toState === 'visible') {\n      // Note: we shouldn't use `this` inside the zone callback,\n      // because it can cause a memory leak.\n      const onEnter = this._onEnter;\n\n      this._ngZone.run(() => {\n        onEnter.next();\n        onEnter.complete();\n      });\n    }\n  }\n\n  /** Begin animation of snack bar entrance into view. */\n  enter(): void {\n    if (!this._destroyed) {\n      this._animationState = 'visible';\n      this._changeDetectorRef.detectChanges();\n      this._screenReaderAnnounce();\n    }\n  }\n\n  /** Begin animation of the snack bar exiting from view. */\n  exit(): Observable<void> {\n    // Note: this one transitions to `hidden`, rather than `void`, in order to handle the case\n    // where multiple snack bars are opened in quick succession (e.g. two consecutive calls to\n    // `MatSnackBar.open`).\n    this._animationState = 'hidden';\n\n    // Mark this element with an 'exit' attribute to indicate that the snackbar has\n    // been dismissed and will soon be removed from the DOM. This is used by the snackbar\n    // test harness.\n    this._elementRef.nativeElement.setAttribute('mat-exit', '');\n\n    // If the snack bar hasn't been announced by the time it exits it wouldn't have been open\n    // long enough to visually read it either, so clear the timeout for announcing.\n    clearTimeout(this._announceTimeoutId);\n\n    return this._onExit;\n  }\n\n  /** Makes sure the exit callbacks have been invoked when the element is destroyed. */\n  ngOnDestroy() {\n    this._destroyed = true;\n    this._completeExit();\n  }\n\n  /**\n   * Waits for the zone to settle before removing the element. Helps prevent\n   * errors where we end up removing an element which is in the middle of an animation.\n   */\n  private _completeExit() {\n    this._ngZone.onMicrotaskEmpty.pipe(take(1)).subscribe(() => {\n      this._onExit.next();\n      this._onExit.complete();\n    });\n  }\n\n  /** Applies the various positioning and user-configured CSS classes to the snack bar. */\n  private _applySnackBarClasses() {\n    const element: HTMLElement = this._elementRef.nativeElement;\n    const panelClasses = this.snackBarConfig.panelClass;\n\n    if (panelClasses) {\n      if (Array.isArray(panelClasses)) {\n        // Note that we can't use a spread here, because IE doesn't support multiple arguments.\n        panelClasses.forEach(cssClass => element.classList.add(cssClass));\n      } else {\n        element.classList.add(panelClasses);\n      }\n    }\n\n    if (this.snackBarConfig.horizontalPosition === 'center') {\n      element.classList.add('mat-snack-bar-center');\n    }\n\n    if (this.snackBarConfig.verticalPosition === 'top') {\n      element.classList.add('mat-snack-bar-top');\n    }\n  }\n\n  /** Asserts that no content is already attached to the container. */\n  private _assertNotAttached() {\n    if (this._portalOutlet.hasAttached() && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n      throw Error('Attempting to attach snack bar content after content is already attached');\n    }\n  }\n\n  /**\n   * Starts a timeout to move the snack bar content to the live region so screen readers will\n   * announce it.\n   */\n  private _screenReaderAnnounce() {\n    if (!this._announceTimeoutId) {\n      this._ngZone.runOutsideAngular(() => {\n        this._announceTimeoutId = setTimeout(() => {\n          const inertElement = this._elementRef.nativeElement.querySelector('[aria-hidden]');\n          const liveElement = this._elementRef.nativeElement.querySelector('[aria-live]');\n\n          if (inertElement && liveElement) {\n            // If an element in the snack bar content is focused before being moved\n            // track it and restore focus after moving to the live region.\n            let focusedElement: HTMLElement | null = null;\n            if (this._platform.isBrowser &&\n                document.activeElement instanceof HTMLElement &&\n                inertElement.contains(document.activeElement)) {\n              focusedElement = document.activeElement;\n            }\n\n            inertElement.removeAttribute('aria-hidden');\n            liveElement.appendChild(inertElement);\n            focusedElement?.focus();\n\n            this._onAnnounce.next();\n            this._onAnnounce.complete();\n          }\n        }, this._announceDelay);\n      });\n    }\n  }\n}\n","<!-- Initially holds the snack bar content, will be empty after announcing to screen readers. -->\n<div aria-hidden=\"true\">\n  <ng-template cdkPortalOutlet></ng-template>\n</div>\n\n<!-- Will receive the snack bar content from the non-live div, move will happen a short delay after opening -->\n<div [attr.aria-live]=\"_live\" [attr.role]=\"_role\"></div>\n"]}

package/esm2020/snack-bar/snack-bar-module.mjs

@@ -0,0 +1,47 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { OverlayModule } from '@angular/cdk/overlay';
+import { PortalModule } from '@angular/cdk/portal';
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { MatCommonModule } from '@angular/material/core';
+import { MatButtonModule } from '@angular/material/button';
+import { SimpleSnackBar } from './simple-snack-bar';
+import { MatSnackBarContainer } from './snack-bar-container';
+import * as i0 from "@angular/core";
+export class MatSnackBarModule {
+}
+MatSnackBarModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: MatSnackBarModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+MatSnackBarModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: MatSnackBarModule, declarations: [MatSnackBarContainer, SimpleSnackBar], imports: [OverlayModule,
+        PortalModule,
+        CommonModule,
+        MatButtonModule,
+        MatCommonModule], exports: [MatSnackBarContainer, MatCommonModule] });
+MatSnackBarModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: MatSnackBarModule, imports: [[
+            OverlayModule,
+            PortalModule,
+            CommonModule,
+            MatButtonModule,
+            MatCommonModule,
+        ], MatCommonModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: MatSnackBarModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        OverlayModule,
+                        PortalModule,
+                        CommonModule,
+                        MatButtonModule,
+                        MatCommonModule,
+                    ],
+                    exports: [MatSnackBarContainer, MatCommonModule],
+                    declarations: [MatSnackBarContainer, SimpleSnackBar],
+                    entryComponents: [MatSnackBarContainer, SimpleSnackBar],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic25hY2stYmFyLW1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy9tYXRlcmlhbC9zbmFjay1iYXIvc25hY2stYmFyLW1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7O0dBTUc7QUFFSCxPQUFPLEVBQUMsYUFBYSxFQUFDLE1BQU0sc0JBQXNCLENBQUM7QUFDbkQsT0FBTyxFQUFDLFlBQVksRUFBQyxNQUFNLHFCQUFxQixDQUFDO0FBQ2pELE9BQU8sRUFBQyxZQUFZLEVBQUMsTUFBTSxpQkFBaUIsQ0FBQztBQUM3QyxPQUFPLEVBQUMsUUFBUSxFQUFDLE1BQU0sZUFBZSxDQUFDO0FBQ3ZDLE9BQU8sRUFBQyxlQUFlLEVBQUMsTUFBTSx3QkFBd0IsQ0FBQztBQUN2RCxPQUFPLEVBQUMsZUFBZSxFQUFDLE1BQU0sMEJBQTBCLENBQUM7QUFDekQsT0FBTyxFQUFDLGNBQWMsRUFBQyxNQUFNLG9CQUFvQixDQUFDO0FBQ2xELE9BQU8sRUFBQyxvQkFBb0IsRUFBQyxNQUFNLHVCQUF1QixDQUFDOztBQWUzRCxNQUFNLE9BQU8saUJBQWlCOztzSEFBakIsaUJBQWlCO3VIQUFqQixpQkFBaUIsaUJBSGIsb0JBQW9CLEVBQUUsY0FBYyxhQVBqRCxhQUFhO1FBQ2IsWUFBWTtRQUNaLFlBQVk7UUFDWixlQUFlO1FBQ2YsZUFBZSxhQUVQLG9CQUFvQixFQUFFLGVBQWU7dUhBSXBDLGlCQUFpQixZQVhuQjtZQUNQLGFBQWE7WUFDYixZQUFZO1lBQ1osWUFBWTtZQUNaLGVBQWU7WUFDZixlQUFlO1NBQ2hCLEVBQytCLGVBQWU7bUdBSXBDLGlCQUFpQjtrQkFaN0IsUUFBUTttQkFBQztvQkFDUixPQUFPLEVBQUU7d0JBQ1AsYUFBYTt3QkFDYixZQUFZO3dCQUNaLFlBQVk7d0JBQ1osZUFBZTt3QkFDZixlQUFlO3FCQUNoQjtvQkFDRCxPQUFPLEVBQUUsQ0FBQyxvQkFBb0IsRUFBRSxlQUFlLENBQUM7b0JBQ2hELFlBQVksRUFBRSxDQUFDLG9CQUFvQixFQUFFLGNBQWMsQ0FBQztvQkFDcEQsZUFBZSxFQUFFLENBQUMsb0JBQW9CLEVBQUUsY0FBYyxDQUFDO2lCQUN4RCIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG5pbXBvcnQge092ZXJsYXlNb2R1bGV9IGZyb20gJ0Bhbmd1bGFyL2Nkay9vdmVybGF5JztcbmltcG9ydCB7UG9ydGFsTW9kdWxlfSBmcm9tICdAYW5ndWxhci9jZGsvcG9ydGFsJztcbmltcG9ydCB7Q29tbW9uTW9kdWxlfSBmcm9tICdAYW5ndWxhci9jb21tb24nO1xuaW1wb3J0IHtOZ01vZHVsZX0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQge01hdENvbW1vbk1vZHVsZX0gZnJvbSAnQGFuZ3VsYXIvbWF0ZXJpYWwvY29yZSc7XG5pbXBvcnQge01hdEJ1dHRvbk1vZHVsZX0gZnJvbSAnQGFuZ3VsYXIvbWF0ZXJpYWwvYnV0dG9uJztcbmltcG9ydCB7U2ltcGxlU25hY2tCYXJ9IGZyb20gJy4vc2ltcGxlLXNuYWNrLWJhcic7XG5pbXBvcnQge01hdFNuYWNrQmFyQ29udGFpbmVyfSBmcm9tICcuL3NuYWNrLWJhci1jb250YWluZXInO1xuXG5cbkBOZ01vZHVsZSh7XG4gIGltcG9ydHM6IFtcbiAgICBPdmVybGF5TW9kdWxlLFxuICAgIFBvcnRhbE1vZHVsZSxcbiAgICBDb21tb25Nb2R1bGUsXG4gICAgTWF0QnV0dG9uTW9kdWxlLFxuICAgIE1hdENvbW1vbk1vZHVsZSxcbiAgXSxcbiAgZXhwb3J0czogW01hdFNuYWNrQmFyQ29udGFpbmVyLCBNYXRDb21tb25Nb2R1bGVdLFxuICBkZWNsYXJhdGlvbnM6IFtNYXRTbmFja0JhckNvbnRhaW5lciwgU2ltcGxlU25hY2tCYXJdLFxuICBlbnRyeUNvbXBvbmVudHM6IFtNYXRTbmFja0JhckNvbnRhaW5lciwgU2ltcGxlU25hY2tCYXJdLFxufSlcbmV4cG9ydCBjbGFzcyBNYXRTbmFja0Jhck1vZHVsZSB7fVxuIl19

package/esm2020/snack-bar/snack-bar-ref.mjs

@@ -0,0 +1,90 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { Subject } from 'rxjs';
+/** Maximum amount 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.
+ */
+export class MatSnackBarRef {
+    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;
+        // Dismiss snackbar on action.
+        this.onAction().subscribe(() => this.dismiss());
+        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();
+        }
+        clearTimeout(this._durationTimeoutId);
+    }
+    /**
+     * Marks the snackbar action clicked.
+     * @deprecated Use `dismissWithAction` instead.
+     * @breaking-change 8.0.0
+     */
+    closeWithAction() {
+        this.dismissWithAction();
+    }
+    /** 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 that is notified when the snack bar is finished closing. */
+    afterDismissed() {
+        return this._afterDismissed;
+    }
+    /** Gets an observable that is notified when the snack bar has opened and appeared. */
+    afterOpened() {
+        return this.containerInstance._onEnter;
+    }
+    /** Gets an observable that is notified when the snack bar action is called. */
+    onAction() {
+        return this._onAction;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"snack-bar-ref.js","sourceRoot":"","sources":["../../../../../../src/material/snack-bar/snack-bar-ref.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {OverlayRef} from '@angular/cdk/overlay';\nimport {Observable, Subject} from 'rxjs';\nimport {_SnackBarContainer} from './snack-bar-container';\n\n\n/** Event that is emitted when a snack bar is dismissed. */\nexport interface MatSnackBarDismiss {\n  /** Whether the snack bar was dismissed using the action button. */\n  dismissedByAction: boolean;\n}\n\n/** Maximum amount of milliseconds that can be passed into setTimeout. */\nconst MAX_TIMEOUT = Math.pow(2, 31) - 1;\n\n/**\n * Reference to a snack bar dispatched from the snack bar service.\n */\nexport class MatSnackBarRef<T> {\n  /** The instance of the component making up the content of the snack bar. */\n  instance: T;\n\n  /**\n   * The instance of the component making up the content of the snack bar.\n   * @docs-private\n   */\n  containerInstance: _SnackBarContainer;\n\n  /** Subject for notifying the user that the snack bar has been dismissed. */\n  private readonly _afterDismissed = new Subject<MatSnackBarDismiss>();\n\n  /** Subject for notifying the user that the snack bar has opened and appeared. */\n  private readonly _afterOpened = new Subject<void>();\n\n  /** Subject for notifying the user that the snack bar action was called. */\n  private readonly _onAction = new Subject<void>();\n\n  /**\n   * Timeout ID for the duration setTimeout call. Used to clear the timeout if the snackbar is\n   * dismissed before the duration passes.\n   */\n  private _durationTimeoutId: any;\n\n  /** Whether the snack bar was dismissed using the action button. */\n  private _dismissedByAction = false;\n\n  constructor(containerInstance: _SnackBarContainer,\n              private _overlayRef: OverlayRef) {\n    this.containerInstance = containerInstance;\n    // Dismiss snackbar on action.\n    this.onAction().subscribe(() => this.dismiss());\n    containerInstance._onExit.subscribe(() => this._finishDismiss());\n  }\n\n  /** Dismisses the snack bar. */\n  dismiss(): void {\n    if (!this._afterDismissed.closed) {\n      this.containerInstance.exit();\n    }\n    clearTimeout(this._durationTimeoutId);\n  }\n\n  /** Marks the snackbar action clicked. */\n  dismissWithAction(): void {\n    if (!this._onAction.closed) {\n      this._dismissedByAction = true;\n      this._onAction.next();\n      this._onAction.complete();\n    }\n    clearTimeout(this._durationTimeoutId);\n  }\n\n\n  /**\n   * Marks the snackbar action clicked.\n   * @deprecated Use `dismissWithAction` instead.\n   * @breaking-change 8.0.0\n   */\n  closeWithAction(): void {\n    this.dismissWithAction();\n  }\n\n  /** Dismisses the snack bar after some duration */\n  _dismissAfter(duration: number): void {\n    // Note that we need to cap the duration to the maximum value for setTimeout, because\n    // it'll revert to 1 if somebody passes in something greater (e.g. `Infinity`). See #17234.\n    this._durationTimeoutId = setTimeout(() => this.dismiss(), Math.min(duration, MAX_TIMEOUT));\n  }\n\n  /** Marks the snackbar as opened */\n  _open(): void {\n    if (!this._afterOpened.closed) {\n      this._afterOpened.next();\n      this._afterOpened.complete();\n    }\n  }\n\n  /** Cleans up the DOM after closing. */\n  private _finishDismiss(): void {\n    this._overlayRef.dispose();\n\n    if (!this._onAction.closed) {\n      this._onAction.complete();\n    }\n\n    this._afterDismissed.next({dismissedByAction: this._dismissedByAction});\n    this._afterDismissed.complete();\n    this._dismissedByAction = false;\n  }\n\n  /** Gets an observable that is notified when the snack bar is finished closing. */\n  afterDismissed(): Observable<MatSnackBarDismiss> {\n    return this._afterDismissed;\n  }\n\n  /** Gets an observable that is notified when the snack bar has opened and appeared. */\n  afterOpened(): Observable<void> {\n    return this.containerInstance._onEnter;\n  }\n\n  /** Gets an observable that is notified when the snack bar action is called. */\n  onAction(): Observable<void> {\n    return this._onAction;\n  }\n}\n"]}