@villedemontreal/angular-ui 13.1.0 → 13.3.0

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

@@ -0,0 +1,272 @@
+import { BasePortalOutlet, CdkPortalOutlet } from '@angular/cdk/portal';
+import { DOCUMENT } from '@angular/common';
+import { ChangeDetectionStrategy, Component, inject, ViewChild, ViewEncapsulation } from '@angular/core';
+import { Subject } from 'rxjs';
+import { take } from 'rxjs/operators';
+import { matSnackBarAnimations } from './snack-bar-animations';
+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";
+let uniqueId = 0;
+/**
+ * Internal component that wraps user-provided snack bar content.
+ * @docs-private
+ */
+export class BaoSnackBarContainerComponent 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;
+        this._document = inject(DOCUMENT);
+        this._trackedModals = new Set();
+        /** 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';
+        /** 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;
+        /** Unique ID of the aria-live element. */
+        this._liveElementId = `bao-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;
+        };
+        // 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();
+        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();
+        this.applySnackBarClasses();
+        const result = this._portalOutlet.attachTemplatePortal(portal);
+        this._afterPortalAttached();
+        return result;
+    }
+    /** 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('bao-snack-bar-center');
+        }
+        if (this.snackBarConfig.verticalPosition === 'top') {
+            element.classList.add('bao-snack-bar-top');
+        }
+    }
+    /**
+     * 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();
+    }
+    /**
+     * 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() {
+        // 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()) {
+            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 = window.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);
+            });
+        }
+    }
+}
+BaoSnackBarContainerComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: BaoSnackBarContainerComponent, deps: [{ token: i0.NgZone }, { token: i0.ElementRef }, { token: i0.ChangeDetectorRef }, { token: i1.Platform }, { token: i2.BaoSnackBarConfig }], target: i0.ɵɵFactoryTarget.Component });
+BaoSnackBarContainerComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.12", type: BaoSnackBarContainerComponent, selector: "bao-snack-bar-container", host: { listeners: { "@state.done": "onAnimationEnd($event)" }, properties: { "@state": "_animationState" }, classAttribute: "bao-snack-bar-container" }, viewQueries: [{ propertyName: "_portalOutlet", first: true, predicate: CdkPortalOutlet, descendants: true, static: true }], usesInheritance: true, ngImport: i0, template: "<!-- Initialy 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\n  [attr.aria-live]=\"_live\"\n  [attr.role]=\"_role\"\n  [attr.id]=\"_liveElementId\"\n></div>\n", styles: [".bao-container{padding-right:16px;padding-left:16px;margin-right:auto;margin-left:auto;width:100%}@media (min-width: 576px){.bao-container{max-width:576px}}@media (min-width: 768px){.bao-container{max-width:768px}}@media (min-width: 992px){.bao-container{max-width:992px}}@media (min-width: 1200px){.bao-container{max-width:1200px}}.bao-row{display:flex;flex-wrap:wrap;margin-right:-16px;margin-left:-16px}.bao-col-12,.bao-col-lg-7{position:relative;width:100%;padding-right:1rem;padding-left:1rem}@media (min-width: 992px){.bao-col-lg-7{flex:0 0 58.33333%;max-width:58.33333%}}.cdk-overlay-pane{width:100%}@media (min-width: 768px){.cdk-overlay-pane{margin:0;width:auto}}.bao-snack-bar-container{border-radius:.25rem;box-sizing:border-box;display:block;margin:1rem;max-width:100vw;min-width:15rem;min-height:3rem;transform-origin:center;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.3.12", ngImport: i0, type: BaoSnackBarContainerComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'bao-snack-bar-container', changeDetection: ChangeDetectionStrategy.Default, encapsulation: ViewEncapsulation.None, animations: [matSnackBarAnimations.snackBarState], host: {
+                        class: 'bao-snack-bar-container',
+                        '[@state]': '_animationState',
+                        '(@state.done)': 'onAnimationEnd($event)'
+                    }, template: "<!-- Initialy 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\n  [attr.aria-live]=\"_live\"\n  [attr.role]=\"_role\"\n  [attr.id]=\"_liveElementId\"\n></div>\n", styles: [".bao-container{padding-right:16px;padding-left:16px;margin-right:auto;margin-left:auto;width:100%}@media (min-width: 576px){.bao-container{max-width:576px}}@media (min-width: 768px){.bao-container{max-width:768px}}@media (min-width: 992px){.bao-container{max-width:992px}}@media (min-width: 1200px){.bao-container{max-width:1200px}}.bao-row{display:flex;flex-wrap:wrap;margin-right:-16px;margin-left:-16px}.bao-col-12,.bao-col-lg-7{position:relative;width:100%;padding-right:1rem;padding-left:1rem}@media (min-width: 992px){.bao-col-lg-7{flex:0 0 58.33333%;max-width:58.33333%}}.cdk-overlay-pane{width:100%}@media (min-width: 768px){.cdk-overlay-pane{margin:0;width:auto}}.bao-snack-bar-container{border-radius:.25rem;box-sizing:border-box;display:block;margin:1rem;max-width:100vw;min-width:15rem;min-height:3rem;transform-origin:center;width:100%}\n"] }]
+        }], ctorParameters: function () { return [{ type: i0.NgZone }, { type: i0.ElementRef }, { type: i0.ChangeDetectorRef }, { type: i1.Platform }, { type: i2.BaoSnackBarConfig }]; }, propDecorators: { _portalOutlet: [{
+                type: ViewChild,
+                args: [CdkPortalOutlet, { static: true }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"snack-bar-container.js","sourceRoot":"","sources":["../../../../../projects/angular-ui/src/lib/snack-bar/snack-bar-container.ts","../../../../../projects/angular-ui/src/lib/snack-bar/snack-bar-container.html"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright (c) 2023 Ville de Montreal. All rights reserved.\n * Licensed under the MIT license.\n * See LICENSE file in the project root for full license information.\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  DomPortal,\n  TemplatePortal\n} from '@angular/cdk/portal';\nimport { DOCUMENT } from '@angular/common';\nimport {\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  ComponentRef,\n  ElementRef,\n  EmbeddedViewRef,\n  inject,\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 { BaoSnackBarConfig } from './snack-bar-config';\n\nlet uniqueId = 0;\n\n/**\n * Internal interface for a snack bar container.\n * @docs-private\n */\nexport interface IBaoSnackBarContainer {\n  snackBarConfig: BaoSnackBarConfig;\n  _onAnnounce: Subject<any>;\n  _onExit: Subject<any>;\n  _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: 'bao-snack-bar-container',\n  templateUrl: 'snack-bar-container.html',\n  styleUrls: ['snack-bar-container.scss'],\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  // eslint-disable-next-line\n  changeDetection: ChangeDetectionStrategy.Default,\n  encapsulation: ViewEncapsulation.None,\n  animations: [matSnackBarAnimations.snackBarState],\n  host: {\n    class: 'bao-snack-bar-container',\n    '[@state]': '_animationState',\n    '(@state.done)': 'onAnimationEnd($event)'\n  }\n})\nexport class BaoSnackBarContainerComponent\n  extends BasePortalOutlet\n  implements OnDestroy, IBaoSnackBarContainer\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  private _document = inject(DOCUMENT);\n  private _trackedModals = new Set<Element>();\n\n  /** Subject for notifying that the snack bar has announced to screen readers. */\n  public readonly _onAnnounce: Subject<void> = new Subject();\n\n  /** Subject for notifying that the snack bar has exited from view. */\n  public readonly _onExit: Subject<void> = new Subject();\n\n  /** Subject for notifying that the snack bar has finished entering the view. */\n  public readonly _onEnter: Subject<void> = new Subject();\n\n  /** The state of the snack bar animations. */\n  public _animationState = 'void';\n\n  /** aria-live value for the live region. */\n  public _live: AriaLivePoliteness;\n\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: number;\n\n  /** Whether the component has been destroyed. */\n  private _destroyed = false;\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  /** Unique ID of the aria-live element. */\n  readonly _liveElementId = `bao-snack-bar-container-live-${uniqueId++}`;\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: BaoSnackBarConfig\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 (\n      snackBarConfig.politeness === 'assertive' &&\n      !snackBarConfig.announcementMessage\n    ) {\n      this._live = 'assertive';\n    } else if (snackBarConfig.politeness === 'off') {\n      this._live = 'off';\n    } else {\n      this._live = 'polite';\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  public attachComponentPortal<T>(portal: ComponentPortal<T>): ComponentRef<T> {\n    this.assertNotAttached();\n    this.applySnackBarClasses();\n    const result = this._portalOutlet.attachComponentPortal(portal);\n    this._afterPortalAttached();\n    return result;\n  }\n\n  /** Attach a template portal as content to this snack bar container. */\n  public attachTemplatePortal<C>(\n    portal: TemplatePortal<C>\n  ): EmbeddedViewRef<C> {\n    this.assertNotAttached();\n    this.applySnackBarClasses();\n    const result = this._portalOutlet.attachTemplatePortal(portal);\n    this._afterPortalAttached();\n    return result;\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  public attachDomPortal = (portal: DomPortal) => {\n    this.assertNotAttached();\n    const result = this._portalOutlet.attachDomPortal(portal);\n    this._afterPortalAttached();\n    return result;\n  };\n\n  /** Handle end of animations, updating the state of the snackbar. */\n  public 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  public 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  public 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  public 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('bao-snack-bar-center');\n    }\n\n    if (this.snackBarConfig.verticalPosition === 'top') {\n      element.classList.add('bao-snack-bar-top');\n    }\n  }\n\n  /**\n   * Called after the portal contents have been attached. Can be\n   * used to modify the DOM once it's guaranteed to be in place.\n   */\n  protected _afterPortalAttached() {\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    this._exposeToModals();\n  }\n\n  /**\n   * Some browsers won't expose the accessibility node of the live element if there is an\n   * `aria-modal` and the live element is outside of it. This method works around the issue by\n   * pointing the `aria-owns` of all modals to the live element.\n   */\n  private _exposeToModals() {\n    // Note that the selector here is limited to CDK overlays at the moment in order to reduce the\n    // section of the DOM we need to look through. This should cover all the cases we support, but\n    // the selector can be expanded if it turns out to be too narrow.\n    const id = this._liveElementId;\n    const modals = this._document.querySelectorAll(\n      'body > .cdk-overlay-container [aria-modal=\"true\"]'\n    );\n\n    for (let i = 0; i < modals.length; i++) {\n      const modal = modals[i];\n      const ariaOwns = modal.getAttribute('aria-owns');\n      this._trackedModals.add(modal);\n\n      if (!ariaOwns) {\n        modal.setAttribute('aria-owns', id);\n      } else if (ariaOwns.indexOf(id) === -1) {\n        modal.setAttribute('aria-owns', ariaOwns + ' ' + id);\n      }\n    }\n  }\n\n  /** Clears the references to the live element from any modals it was added to. */\n  private _clearFromModals() {\n    this._trackedModals.forEach(modal => {\n      const ariaOwns = modal.getAttribute('aria-owns');\n\n      if (ariaOwns) {\n        const newValue = ariaOwns.replace(this._liveElementId, '').trim();\n\n        if (newValue.length > 0) {\n          modal.setAttribute('aria-owns', newValue);\n        } else {\n          modal.removeAttribute('aria-owns');\n        }\n      }\n    });\n    this._trackedModals.clear();\n  }\n\n  /** Asserts that no content is already attached to the container. */\n  private assertNotAttached() {\n    if (this._portalOutlet.hasAttached()) {\n      throw Error(\n        'Attempting to attach snack bar content after content is already attached'\n      );\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 = window.setTimeout(() => {\n          const inertElement =\n            this._elementRef.nativeElement.querySelector('[aria-hidden]');\n          const liveElement =\n            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 (\n              this._platform.isBrowser &&\n              document.activeElement instanceof HTMLElement &&\n              inertElement.contains(document.activeElement)\n            ) {\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","<!-- Initialy 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\n  [attr.aria-live]=\"_live\"\n  [attr.role]=\"_role\"\n  [attr.id]=\"_liveElementId\"\n></div>\n"]}

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

@@ -0,0 +1,75 @@
+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 BaoSnackBarRef {
+    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();
+        }
+    }
+    /** 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.
+        // @TODO: window.setTimeout() ?
+        this._durationTimeoutId = window.setTimeout(() => this.dismiss(), Math.min(duration, MAX_TIMEOUT));
+    }
+    /** Marks the snackbar as opened */
+    open() {
+        if (!this._afterOpened.closed) {
+            this._afterOpened.next();
+            this._afterOpened.complete();
+        }
+    }
+    /** 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;
+    }
+    /** 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;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"snack-bar-ref.js","sourceRoot":"","sources":["../../../../../projects/angular-ui/src/lib/snack-bar/snack-bar-ref.ts"],"names":[],"mappings":"AAMA,OAAO,EAAc,OAAO,EAAE,MAAM,MAAM,CAAC;AAS3C,yEAAyE;AACzE,MAAM,WAAW,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,CAAC;AAExC;;GAEG;AACH,MAAM,OAAO,cAAc;IA4BzB,YACE,iBAAwC,EAChC,WAAuB;QAAvB,gBAAW,GAAX,WAAW,CAAY;QApBjC,4EAA4E;QAC3D,oBAAe,GAAG,IAAI,OAAO,EAAuB,CAAC;QAEtE,iFAAiF;QAChE,iBAAY,GAAG,IAAI,OAAO,EAAQ,CAAC;QAEpD,2EAA2E;QAC1D,cAAS,GAAG,IAAI,OAAO,EAAQ,CAAC;QAQjD,mEAAmE;QAC3D,uBAAkB,GAAG,KAAK,CAAC;QAMjC,IAAI,CAAC,iBAAiB,GAAG,iBAAiB,CAAC;QAC3C,8BAA8B;QAC9B,IAAI,CAAC,QAAQ,EAAE,CAAC,SAAS,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC;QAChD,iBAAiB,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC,CAAC;IAClE,CAAC;IAED,+BAA+B;IACxB,OAAO;QACZ,IAAI,CAAC,IAAI,CAAC,eAAe,CAAC,MAAM,EAAE;YAChC,IAAI,CAAC,iBAAiB,CAAC,IAAI,EAAE,CAAC;SAC/B;QACD,YAAY,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC;IACxC,CAAC;IAED,yCAAyC;IAClC,iBAAiB;QACtB,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE;YAC1B,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC;YAC/B,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC;YACtB,IAAI,CAAC,SAAS,CAAC,QAAQ,EAAE,CAAC;SAC3B;IACH,CAAC;IAED,kDAAkD;IAC3C,YAAY,CAAC,QAAgB;QAClC,qFAAqF;QACrF,2FAA2F;QAE3F,+BAA+B;QAC/B,IAAI,CAAC,kBAAkB,GAAG,MAAM,CAAC,UAAU,CACzC,GAAG,EAAE,CAAC,IAAI,CAAC,OAAO,EAAE,EACpB,IAAI,CAAC,GAAG,CAAC,QAAQ,EAAE,WAAW,CAAC,CAChC,CAAC;IACJ,CAAC;IAED,mCAAmC;IAC5B,IAAI;QACT,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,MAAM,EAAE;YAC7B,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC;YACzB,IAAI,CAAC,YAAY,CAAC,QAAQ,EAAE,CAAC;SAC9B;IACH,CAAC;IAED,kFAAkF;IAC3E,cAAc;QACnB,OAAO,IAAI,CAAC,eAAe,CAAC;IAC9B,CAAC;IAED,sFAAsF;IAC/E,WAAW;QAChB,OAAO,IAAI,CAAC,iBAAiB,CAAC,QAAQ,CAAC;IACzC,CAAC;IAED,+EAA+E;IACxE,QAAQ;QACb,OAAO,IAAI,CAAC,SAAS,CAAC;IACxB,CAAC;IAED,uCAAuC;IAC/B,aAAa;QACnB,IAAI,CAAC,WAAW,CAAC,OAAO,EAAE,CAAC;QAE3B,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE;YAC1B,IAAI,CAAC,SAAS,CAAC,QAAQ,EAAE,CAAC;SAC3B;QAED,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,EAAE,iBAAiB,EAAE,IAAI,CAAC,kBAAkB,EAAE,CAAC,CAAC;QAC1E,IAAI,CAAC,eAAe,CAAC,QAAQ,EAAE,CAAC;QAChC,IAAI,CAAC,kBAAkB,GAAG,KAAK,CAAC;IAClC,CAAC;CACF","sourcesContent":["/*\n * Copyright (c) 2023 Ville de Montreal. All rights reserved.\n * Licensed under the MIT license.\n * See LICENSE file in the project root for full license information.\n */\nimport { OverlayRef } from '@angular/cdk/overlay';\nimport { Observable, Subject } from 'rxjs';\nimport { IBaoSnackBarContainer } from './snack-bar-container';\n\n/** Event that is emitted when a snack bar is dismissed. */\nexport interface IBaoSnackBarDismiss {\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 BaoSnackBarRef<T> {\n  /** The instance of the component making up the content of the snack bar. */\n  public instance: T;\n\n  /**\n   * The instance of the component making up the content of the snack bar.\n   * @docs-private\n   */\n  public containerInstance: IBaoSnackBarContainer;\n\n  /** Subject for notifying the user that the snack bar has been dismissed. */\n  private readonly _afterDismissed = new Subject<IBaoSnackBarDismiss>();\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: number;\n\n  /** Whether the snack bar was dismissed using the action button. */\n  private _dismissedByAction = false;\n\n  constructor(\n    containerInstance: IBaoSnackBarContainer,\n    private _overlayRef: OverlayRef\n  ) {\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  public 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  public dismissWithAction(): void {\n    if (!this._onAction.closed) {\n      this._dismissedByAction = true;\n      this._onAction.next();\n      this._onAction.complete();\n    }\n  }\n\n  /** Dismisses the snack bar after some duration */\n  public 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\n    // @TODO: window.setTimeout() ?\n    this._durationTimeoutId = window.setTimeout(\n      () => this.dismiss(),\n      Math.min(duration, MAX_TIMEOUT)\n    );\n  }\n\n  /** Marks the snackbar as opened */\n  public open(): void {\n    if (!this._afterOpened.closed) {\n      this._afterOpened.next();\n      this._afterOpened.complete();\n    }\n  }\n\n  /** Gets an observable that is notified when the snack bar is finished closing. */\n  public afterDismissed(): Observable<IBaoSnackBarDismiss> {\n    return this._afterDismissed;\n  }\n\n  /** Gets an observable that is notified when the snack bar has opened and appeared. */\n  public 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  public onAction(): Observable<void> {\n    return this._onAction;\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"]}