source: trip-planner-front/node_modules/@angular/material/bundles/material-snack-bar.umd.js@ 6c1585f

Last change on this file since 6c1585f was 6a3a178, checked in by Ema <ema_spirova@…>, 3 years ago

initial commit
  • Property mode set to 100644
File size: 51.1 KB
Line 
1(function (global, factory) {
2 typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/cdk/overlay'), require('@angular/cdk/portal'), require('@angular/common'), require('@angular/core'), require('@angular/material/core'), require('@angular/material/button'), require('rxjs'), require('@angular/cdk/platform'), require('rxjs/operators'), require('@angular/animations'), require('@angular/cdk/a11y'), require('@angular/cdk/layout')) :
3 typeof define === 'function' && define.amd ? define('@angular/material/snack-bar', ['exports', '@angular/cdk/overlay', '@angular/cdk/portal', '@angular/common', '@angular/core', '@angular/material/core', '@angular/material/button', 'rxjs', '@angular/cdk/platform', 'rxjs/operators', '@angular/animations', '@angular/cdk/a11y', '@angular/cdk/layout'], factory) :
4 (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory((global.ng = global.ng || {}, global.ng.material = global.ng.material || {}, global.ng.material.snackBar = {}), global.ng.cdk.overlay, global.ng.cdk.portal, global.ng.common, global.ng.core, global.ng.material.core, global.ng.material.button, global.rxjs, global.ng.cdk.platform, global.rxjs.operators, global.ng.animations, global.ng.cdk.a11y, global.ng.cdk.layout));
5}(this, (function (exports, i1, portal, common, i0, core, button, rxjs, platform, operators, animations, i2, i3) { 'use strict';
6
7 function _interopNamespace(e) {
8 if (e && e.__esModule) return e;
9 var n = Object.create(null);
10 if (e) {
11 Object.keys(e).forEach(function (k) {
12 if (k !== 'default') {
13 var d = Object.getOwnPropertyDescriptor(e, k);
14 Object.defineProperty(n, k, d.get ? d : {
15 enumerable: true,
16 get: function () {
17 return e[k];
18 }
19 });
20 }
21 });
22 }
23 n['default'] = e;
24 return Object.freeze(n);
25 }
26
27 var i1__namespace = /*#__PURE__*/_interopNamespace(i1);
28 var i0__namespace = /*#__PURE__*/_interopNamespace(i0);
29 var i2__namespace = /*#__PURE__*/_interopNamespace(i2);
30 var i3__namespace = /*#__PURE__*/_interopNamespace(i3);
31
32 /**
33 * @license
34 * Copyright Google LLC All Rights Reserved.
35 *
36 * Use of this source code is governed by an MIT-style license that can be
37 * found in the LICENSE file at https://angular.io/license
38 */
39 /** Injection token that can be used to access the data that was passed in to a snack bar. */
40 var MAT_SNACK_BAR_DATA = new i0.InjectionToken('MatSnackBarData');
41 /**
42 * Configuration used when opening a snack-bar.
43 */
44 var MatSnackBarConfig = /** @class */ (function () {
45 function MatSnackBarConfig() {
46 /** The politeness level for the MatAriaLiveAnnouncer announcement. */
47 this.politeness = 'assertive';
48 /**
49 * Message to be announced by the LiveAnnouncer. When opening a snackbar without a custom
50 * component or template, the announcement message will default to the specified message.
51 */
52 this.announcementMessage = '';
53 /** The length of time in milliseconds to wait before automatically dismissing the snack bar. */
54 this.duration = 0;
55 /** Data being injected into the child component. */
56 this.data = null;
57 /** The horizontal position to place the snack bar. */
58 this.horizontalPosition = 'center';
59 /** The vertical position to place the snack bar. */
60 this.verticalPosition = 'bottom';
61 }
62 return MatSnackBarConfig;
63 }());
64
65 /**
66 * @license
67 * Copyright Google LLC All Rights Reserved.
68 *
69 * Use of this source code is governed by an MIT-style license that can be
70 * found in the LICENSE file at https://angular.io/license
71 */
72 /** Maximum amount of milliseconds that can be passed into setTimeout. */
73 var MAX_TIMEOUT = Math.pow(2, 31) - 1;
74 /**
75 * Reference to a snack bar dispatched from the snack bar service.
76 */
77 var MatSnackBarRef = /** @class */ (function () {
78 function MatSnackBarRef(containerInstance, _overlayRef) {
79 var _this = this;
80 this._overlayRef = _overlayRef;
81 /** Subject for notifying the user that the snack bar has been dismissed. */
82 this._afterDismissed = new rxjs.Subject();
83 /** Subject for notifying the user that the snack bar has opened and appeared. */
84 this._afterOpened = new rxjs.Subject();
85 /** Subject for notifying the user that the snack bar action was called. */
86 this._onAction = new rxjs.Subject();
87 /** Whether the snack bar was dismissed using the action button. */
88 this._dismissedByAction = false;
89 this.containerInstance = containerInstance;
90 // Dismiss snackbar on action.
91 this.onAction().subscribe(function () { return _this.dismiss(); });
92 containerInstance._onExit.subscribe(function () { return _this._finishDismiss(); });
93 }
94 /** Dismisses the snack bar. */
95 MatSnackBarRef.prototype.dismiss = function () {
96 if (!this._afterDismissed.closed) {
97 this.containerInstance.exit();
98 }
99 clearTimeout(this._durationTimeoutId);
100 };
101 /** Marks the snackbar action clicked. */
102 MatSnackBarRef.prototype.dismissWithAction = function () {
103 if (!this._onAction.closed) {
104 this._dismissedByAction = true;
105 this._onAction.next();
106 this._onAction.complete();
107 }
108 clearTimeout(this._durationTimeoutId);
109 };
110 /**
111 * Marks the snackbar action clicked.
112 * @deprecated Use `dismissWithAction` instead.
113 * @breaking-change 8.0.0
114 */
115 MatSnackBarRef.prototype.closeWithAction = function () {
116 this.dismissWithAction();
117 };
118 /** Dismisses the snack bar after some duration */
119 MatSnackBarRef.prototype._dismissAfter = function (duration) {
120 var _this = this;
121 // Note that we need to cap the duration to the maximum value for setTimeout, because
122 // it'll revert to 1 if somebody passes in something greater (e.g. `Infinity`). See #17234.
123 this._durationTimeoutId = setTimeout(function () { return _this.dismiss(); }, Math.min(duration, MAX_TIMEOUT));
124 };
125 /** Marks the snackbar as opened */
126 MatSnackBarRef.prototype._open = function () {
127 if (!this._afterOpened.closed) {
128 this._afterOpened.next();
129 this._afterOpened.complete();
130 }
131 };
132 /** Cleans up the DOM after closing. */
133 MatSnackBarRef.prototype._finishDismiss = function () {
134 this._overlayRef.dispose();
135 if (!this._onAction.closed) {
136 this._onAction.complete();
137 }
138 this._afterDismissed.next({ dismissedByAction: this._dismissedByAction });
139 this._afterDismissed.complete();
140 this._dismissedByAction = false;
141 };
142 /** Gets an observable that is notified when the snack bar is finished closing. */
143 MatSnackBarRef.prototype.afterDismissed = function () {
144 return this._afterDismissed;
145 };
146 /** Gets an observable that is notified when the snack bar has opened and appeared. */
147 MatSnackBarRef.prototype.afterOpened = function () {
148 return this.containerInstance._onEnter;
149 };
150 /** Gets an observable that is notified when the snack bar action is called. */
151 MatSnackBarRef.prototype.onAction = function () {
152 return this._onAction;
153 };
154 return MatSnackBarRef;
155 }());
156
157 /**
158 * @license
159 * Copyright Google LLC All Rights Reserved.
160 *
161 * Use of this source code is governed by an MIT-style license that can be
162 * found in the LICENSE file at https://angular.io/license
163 */
164 /**
165 * A component used to open as the default snack bar, matching material spec.
166 * This should only be used internally by the snack bar service.
167 */
168 var SimpleSnackBar = /** @class */ (function () {
169 function SimpleSnackBar(snackBarRef, data) {
170 this.snackBarRef = snackBarRef;
171 this.data = data;
172 }
173 /** Performs the action on the snack bar. */
174 SimpleSnackBar.prototype.action = function () {
175 this.snackBarRef.dismissWithAction();
176 };
177 Object.defineProperty(SimpleSnackBar.prototype, "hasAction", {
178 /** If the action button should be shown. */
179 get: function () {
180 return !!this.data.action;
181 },
182 enumerable: false,
183 configurable: true
184 });
185 return SimpleSnackBar;
186 }());
187 SimpleSnackBar.decorators = [
188 { type: i0.Component, args: [{
189 selector: 'simple-snack-bar',
190 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",
191 encapsulation: i0.ViewEncapsulation.None,
192 changeDetection: i0.ChangeDetectionStrategy.OnPush,
193 host: {
194 'class': 'mat-simple-snackbar',
195 },
196 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"]
197 },] }
198 ];
199 SimpleSnackBar.ctorParameters = function () { return [
200 { type: MatSnackBarRef },
201 { type: undefined, decorators: [{ type: i0.Inject, args: [MAT_SNACK_BAR_DATA,] }] }
202 ]; };
203
204 /*! *****************************************************************************
205 Copyright (c) Microsoft Corporation.
206
207 Permission to use, copy, modify, and/or distribute this software for any
208 purpose with or without fee is hereby granted.
209
210 THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
211 REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
212 AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
213 INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
214 LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
215 OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
216 PERFORMANCE OF THIS SOFTWARE.
217 ***************************************************************************** */
218 /* global Reflect, Promise */
219 var extendStatics = function (d, b) {
220 extendStatics = Object.setPrototypeOf ||
221 ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
222 function (d, b) { for (var p in b)
223 if (Object.prototype.hasOwnProperty.call(b, p))
224 d[p] = b[p]; };
225 return extendStatics(d, b);
226 };
227 function __extends(d, b) {
228 if (typeof b !== "function" && b !== null)
229 throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
230 extendStatics(d, b);
231 function __() { this.constructor = d; }
232 d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
233 }
234 var __assign = function () {
235 __assign = Object.assign || function __assign(t) {
236 for (var s, i = 1, n = arguments.length; i < n; i++) {
237 s = arguments[i];
238 for (var p in s)
239 if (Object.prototype.hasOwnProperty.call(s, p))
240 t[p] = s[p];
241 }
242 return t;
243 };
244 return __assign.apply(this, arguments);
245 };
246 function __rest(s, e) {
247 var t = {};
248 for (var p in s)
249 if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
250 t[p] = s[p];
251 if (s != null && typeof Object.getOwnPropertySymbols === "function")
252 for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
253 if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
254 t[p[i]] = s[p[i]];
255 }
256 return t;
257 }
258 function __decorate(decorators, target, key, desc) {
259 var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
260 if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
261 r = Reflect.decorate(decorators, target, key, desc);
262 else
263 for (var i = decorators.length - 1; i >= 0; i--)
264 if (d = decorators[i])
265 r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
266 return c > 3 && r && Object.defineProperty(target, key, r), r;
267 }
268 function __param(paramIndex, decorator) {
269 return function (target, key) { decorator(target, key, paramIndex); };
270 }
271 function __metadata(metadataKey, metadataValue) {
272 if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
273 return Reflect.metadata(metadataKey, metadataValue);
274 }
275 function __awaiter(thisArg, _arguments, P, generator) {
276 function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
277 return new (P || (P = Promise))(function (resolve, reject) {
278 function fulfilled(value) { try {
279 step(generator.next(value));
280 }
281 catch (e) {
282 reject(e);
283 } }
284 function rejected(value) { try {
285 step(generator["throw"](value));
286 }
287 catch (e) {
288 reject(e);
289 } }
290 function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
291 step((generator = generator.apply(thisArg, _arguments || [])).next());
292 });
293 }
294 function __generator(thisArg, body) {
295 var _ = { label: 0, sent: function () { if (t[0] & 1)
296 throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
297 return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function () { return this; }), g;
298 function verb(n) { return function (v) { return step([n, v]); }; }
299 function step(op) {
300 if (f)
301 throw new TypeError("Generator is already executing.");
302 while (_)
303 try {
304 if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done)
305 return t;
306 if (y = 0, t)
307 op = [op[0] & 2, t.value];
308 switch (op[0]) {
309 case 0:
310 case 1:
311 t = op;
312 break;
313 case 4:
314 _.label++;
315 return { value: op[1], done: false };
316 case 5:
317 _.label++;
318 y = op[1];
319 op = [0];
320 continue;
321 case 7:
322 op = _.ops.pop();
323 _.trys.pop();
324 continue;
325 default:
326 if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
327 _ = 0;
328 continue;
329 }
330 if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) {
331 _.label = op[1];
332 break;
333 }
334 if (op[0] === 6 && _.label < t[1]) {
335 _.label = t[1];
336 t = op;
337 break;
338 }
339 if (t && _.label < t[2]) {
340 _.label = t[2];
341 _.ops.push(op);
342 break;
343 }
344 if (t[2])
345 _.ops.pop();
346 _.trys.pop();
347 continue;
348 }
349 op = body.call(thisArg, _);
350 }
351 catch (e) {
352 op = [6, e];
353 y = 0;
354 }
355 finally {
356 f = t = 0;
357 }
358 if (op[0] & 5)
359 throw op[1];
360 return { value: op[0] ? op[1] : void 0, done: true };
361 }
362 }
363 var __createBinding = Object.create ? (function (o, m, k, k2) {
364 if (k2 === undefined)
365 k2 = k;
366 Object.defineProperty(o, k2, { enumerable: true, get: function () { return m[k]; } });
367 }) : (function (o, m, k, k2) {
368 if (k2 === undefined)
369 k2 = k;
370 o[k2] = m[k];
371 });
372 function __exportStar(m, o) {
373 for (var p in m)
374 if (p !== "default" && !Object.prototype.hasOwnProperty.call(o, p))
375 __createBinding(o, m, p);
376 }
377 function __values(o) {
378 var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
379 if (m)
380 return m.call(o);
381 if (o && typeof o.length === "number")
382 return {
383 next: function () {
384 if (o && i >= o.length)
385 o = void 0;
386 return { value: o && o[i++], done: !o };
387 }
388 };
389 throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
390 }
391 function __read(o, n) {
392 var m = typeof Symbol === "function" && o[Symbol.iterator];
393 if (!m)
394 return o;
395 var i = m.call(o), r, ar = [], e;
396 try {
397 while ((n === void 0 || n-- > 0) && !(r = i.next()).done)
398 ar.push(r.value);
399 }
400 catch (error) {
401 e = { error: error };
402 }
403 finally {
404 try {
405 if (r && !r.done && (m = i["return"]))
406 m.call(i);
407 }
408 finally {
409 if (e)
410 throw e.error;
411 }
412 }
413 return ar;
414 }
415 /** @deprecated */
416 function __spread() {
417 for (var ar = [], i = 0; i < arguments.length; i++)
418 ar = ar.concat(__read(arguments[i]));
419 return ar;
420 }
421 /** @deprecated */
422 function __spreadArrays() {
423 for (var s = 0, i = 0, il = arguments.length; i < il; i++)
424 s += arguments[i].length;
425 for (var r = Array(s), k = 0, i = 0; i < il; i++)
426 for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
427 r[k] = a[j];
428 return r;
429 }
430 function __spreadArray(to, from, pack) {
431 if (pack || arguments.length === 2)
432 for (var i = 0, l = from.length, ar; i < l; i++) {
433 if (ar || !(i in from)) {
434 if (!ar)
435 ar = Array.prototype.slice.call(from, 0, i);
436 ar[i] = from[i];
437 }
438 }
439 return to.concat(ar || from);
440 }
441 function __await(v) {
442 return this instanceof __await ? (this.v = v, this) : new __await(v);
443 }
444 function __asyncGenerator(thisArg, _arguments, generator) {
445 if (!Symbol.asyncIterator)
446 throw new TypeError("Symbol.asyncIterator is not defined.");
447 var g = generator.apply(thisArg, _arguments || []), i, q = [];
448 return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
449 function verb(n) { if (g[n])
450 i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
451 function resume(n, v) { try {
452 step(g[n](v));
453 }
454 catch (e) {
455 settle(q[0][3], e);
456 } }
457 function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
458 function fulfill(value) { resume("next", value); }
459 function reject(value) { resume("throw", value); }
460 function settle(f, v) { if (f(v), q.shift(), q.length)
461 resume(q[0][0], q[0][1]); }
462 }
463 function __asyncDelegator(o) {
464 var i, p;
465 return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
466 function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v; } : f; }
467 }
468 function __asyncValues(o) {
469 if (!Symbol.asyncIterator)
470 throw new TypeError("Symbol.asyncIterator is not defined.");
471 var m = o[Symbol.asyncIterator], i;
472 return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
473 function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
474 function settle(resolve, reject, d, v) { Promise.resolve(v).then(function (v) { resolve({ value: v, done: d }); }, reject); }
475 }
476 function __makeTemplateObject(cooked, raw) {
477 if (Object.defineProperty) {
478 Object.defineProperty(cooked, "raw", { value: raw });
479 }
480 else {
481 cooked.raw = raw;
482 }
483 return cooked;
484 }
485 ;
486 var __setModuleDefault = Object.create ? (function (o, v) {
487 Object.defineProperty(o, "default", { enumerable: true, value: v });
488 }) : function (o, v) {
489 o["default"] = v;
490 };
491 function __importStar(mod) {
492 if (mod && mod.__esModule)
493 return mod;
494 var result = {};
495 if (mod != null)
496 for (var k in mod)
497 if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k))
498 __createBinding(result, mod, k);
499 __setModuleDefault(result, mod);
500 return result;
501 }
502 function __importDefault(mod) {
503 return (mod && mod.__esModule) ? mod : { default: mod };
504 }
505 function __classPrivateFieldGet(receiver, state, kind, f) {
506 if (kind === "a" && !f)
507 throw new TypeError("Private accessor was defined without a getter");
508 if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
509 throw new TypeError("Cannot read private member from an object whose class did not declare it");
510 return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
511 }
512 function __classPrivateFieldSet(receiver, state, value, kind, f) {
513 if (kind === "m")
514 throw new TypeError("Private method is not writable");
515 if (kind === "a" && !f)
516 throw new TypeError("Private accessor was defined without a setter");
517 if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
518 throw new TypeError("Cannot write private member to an object whose class did not declare it");
519 return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
520 }
521
522 /**
523 * @license
524 * Copyright Google LLC All Rights Reserved.
525 *
526 * Use of this source code is governed by an MIT-style license that can be
527 * found in the LICENSE file at https://angular.io/license
528 */
529 /**
530 * Animations used by the Material snack bar.
531 * @docs-private
532 */
533 var matSnackBarAnimations = {
534 /** Animation that shows and hides a snack bar. */
535 snackBarState: animations.trigger('state', [
536 animations.state('void, hidden', animations.style({
537 transform: 'scale(0.8)',
538 opacity: 0,
539 })),
540 animations.state('visible', animations.style({
541 transform: 'scale(1)',
542 opacity: 1,
543 })),
544 animations.transition('* => visible', animations.animate('150ms cubic-bezier(0, 0, 0.2, 1)')),
545 animations.transition('* => void, * => hidden', animations.animate('75ms cubic-bezier(0.4, 0.0, 1, 1)', animations.style({
546 opacity: 0
547 }))),
548 ])
549 };
550
551 /**
552 * Internal component that wraps user-provided snack bar content.
553 * @docs-private
554 */
555 var MatSnackBarContainer = /** @class */ (function (_super) {
556 __extends(MatSnackBarContainer, _super);
557 function MatSnackBarContainer(_ngZone, _elementRef, _changeDetectorRef, _platform,
558 /** The snack bar configuration. */
559 snackBarConfig) {
560 var _this = _super.call(this) || this;
561 _this._ngZone = _ngZone;
562 _this._elementRef = _elementRef;
563 _this._changeDetectorRef = _changeDetectorRef;
564 _this._platform = _platform;
565 _this.snackBarConfig = snackBarConfig;
566 /** The number of milliseconds to wait before announcing the snack bar's content. */
567 _this._announceDelay = 150;
568 /** Whether the component has been destroyed. */
569 _this._destroyed = false;
570 /** Subject for notifying that the snack bar has announced to screen readers. */
571 _this._onAnnounce = new rxjs.Subject();
572 /** Subject for notifying that the snack bar has exited from view. */
573 _this._onExit = new rxjs.Subject();
574 /** Subject for notifying that the snack bar has finished entering the view. */
575 _this._onEnter = new rxjs.Subject();
576 /** The state of the snack bar animations. */
577 _this._animationState = 'void';
578 /**
579 * Attaches a DOM portal to the snack bar container.
580 * @deprecated To be turned into a method.
581 * @breaking-change 10.0.0
582 */
583 _this.attachDomPortal = function (portal) {
584 _this._assertNotAttached();
585 _this._applySnackBarClasses();
586 return _this._portalOutlet.attachDomPortal(portal);
587 };
588 // Use aria-live rather than a live role like 'alert' or 'status'
589 // because NVDA and JAWS have show inconsistent behavior with live roles.
590 if (snackBarConfig.politeness === 'assertive' && !snackBarConfig.announcementMessage) {
591 _this._live = 'assertive';
592 }
593 else if (snackBarConfig.politeness === 'off') {
594 _this._live = 'off';
595 }
596 else {
597 _this._live = 'polite';
598 }
599 // Only set role for Firefox. Set role based on aria-live because setting role="alert" implies
600 // aria-live="assertive" which may cause issues if aria-live is set to "polite" above.
601 if (_this._platform.FIREFOX) {
602 if (_this._live === 'polite') {
603 _this._role = 'status';
604 }
605 if (_this._live === 'assertive') {
606 _this._role = 'alert';
607 }
608 }
609 return _this;
610 }
611 /** Attach a component portal as content to this snack bar container. */
612 MatSnackBarContainer.prototype.attachComponentPortal = function (portal) {
613 this._assertNotAttached();
614 this._applySnackBarClasses();
615 return this._portalOutlet.attachComponentPortal(portal);
616 };
617 /** Attach a template portal as content to this snack bar container. */
618 MatSnackBarContainer.prototype.attachTemplatePortal = function (portal) {
619 this._assertNotAttached();
620 this._applySnackBarClasses();
621 return this._portalOutlet.attachTemplatePortal(portal);
622 };
623 /** Handle end of animations, updating the state of the snackbar. */
624 MatSnackBarContainer.prototype.onAnimationEnd = function (event) {
625 var fromState = event.fromState, toState = event.toState;
626 if ((toState === 'void' && fromState !== 'void') || toState === 'hidden') {
627 this._completeExit();
628 }
629 if (toState === 'visible') {
630 // Note: we shouldn't use `this` inside the zone callback,
631 // because it can cause a memory leak.
632 var onEnter_1 = this._onEnter;
633 this._ngZone.run(function () {
634 onEnter_1.next();
635 onEnter_1.complete();
636 });
637 }
638 };
639 /** Begin animation of snack bar entrance into view. */
640 MatSnackBarContainer.prototype.enter = function () {
641 if (!this._destroyed) {
642 this._animationState = 'visible';
643 this._changeDetectorRef.detectChanges();
644 this._screenReaderAnnounce();
645 }
646 };
647 /** Begin animation of the snack bar exiting from view. */
648 MatSnackBarContainer.prototype.exit = function () {
649 // Note: this one transitions to `hidden`, rather than `void`, in order to handle the case
650 // where multiple snack bars are opened in quick succession (e.g. two consecutive calls to
651 // `MatSnackBar.open`).
652 this._animationState = 'hidden';
653 // Mark this element with an 'exit' attribute to indicate that the snackbar has
654 // been dismissed and will soon be removed from the DOM. This is used by the snackbar
655 // test harness.
656 this._elementRef.nativeElement.setAttribute('mat-exit', '');
657 // If the snack bar hasn't been announced by the time it exits it wouldn't have been open
658 // long enough to visually read it either, so clear the timeout for announcing.
659 clearTimeout(this._announceTimeoutId);
660 return this._onExit;
661 };
662 /** Makes sure the exit callbacks have been invoked when the element is destroyed. */
663 MatSnackBarContainer.prototype.ngOnDestroy = function () {
664 this._destroyed = true;
665 this._completeExit();
666 };
667 /**
668 * Waits for the zone to settle before removing the element. Helps prevent
669 * errors where we end up removing an element which is in the middle of an animation.
670 */
671 MatSnackBarContainer.prototype._completeExit = function () {
672 var _this = this;
673 this._ngZone.onMicrotaskEmpty.pipe(operators.take(1)).subscribe(function () {
674 _this._onExit.next();
675 _this._onExit.complete();
676 });
677 };
678 /** Applies the various positioning and user-configured CSS classes to the snack bar. */
679 MatSnackBarContainer.prototype._applySnackBarClasses = function () {
680 var element = this._elementRef.nativeElement;
681 var panelClasses = this.snackBarConfig.panelClass;
682 if (panelClasses) {
683 if (Array.isArray(panelClasses)) {
684 // Note that we can't use a spread here, because IE doesn't support multiple arguments.
685 panelClasses.forEach(function (cssClass) { return element.classList.add(cssClass); });
686 }
687 else {
688 element.classList.add(panelClasses);
689 }
690 }
691 if (this.snackBarConfig.horizontalPosition === 'center') {
692 element.classList.add('mat-snack-bar-center');
693 }
694 if (this.snackBarConfig.verticalPosition === 'top') {
695 element.classList.add('mat-snack-bar-top');
696 }
697 };
698 /** Asserts that no content is already attached to the container. */
699 MatSnackBarContainer.prototype._assertNotAttached = function () {
700 if (this._portalOutlet.hasAttached() && (typeof ngDevMode === 'undefined' || ngDevMode)) {
701 throw Error('Attempting to attach snack bar content after content is already attached');
702 }
703 };
704 /**
705 * Starts a timeout to move the snack bar content to the live region so screen readers will
706 * announce it.
707 */
708 MatSnackBarContainer.prototype._screenReaderAnnounce = function () {
709 var _this = this;
710 if (!this._announceTimeoutId) {
711 this._ngZone.runOutsideAngular(function () {
712 _this._announceTimeoutId = setTimeout(function () {
713 var inertElement = _this._elementRef.nativeElement.querySelector('[aria-hidden]');
714 var liveElement = _this._elementRef.nativeElement.querySelector('[aria-live]');
715 if (inertElement && liveElement) {
716 // If an element in the snack bar content is focused before being moved
717 // track it and restore focus after moving to the live region.
718 var focusedElement = null;
719 if (_this._platform.isBrowser &&
720 document.activeElement instanceof HTMLElement &&
721 inertElement.contains(document.activeElement)) {
722 focusedElement = document.activeElement;
723 }
724 inertElement.removeAttribute('aria-hidden');
725 liveElement.appendChild(inertElement);
726 focusedElement === null || focusedElement === void 0 ? void 0 : focusedElement.focus();
727 _this._onAnnounce.next();
728 _this._onAnnounce.complete();
729 }
730 }, _this._announceDelay);
731 });
732 }
733 };
734 return MatSnackBarContainer;
735 }(portal.BasePortalOutlet));
736 MatSnackBarContainer.decorators = [
737 { type: i0.Component, args: [{
738 selector: 'snack-bar-container',
739 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",
740 // In Ivy embedded views will be change detected from their declaration place, rather than
741 // where they were stamped out. This means that we can't have the snack bar container be OnPush,
742 // because it might cause snack bars that were opened from a template not to be out of date.
743 // tslint:disable-next-line:validate-decorators
744 changeDetection: i0.ChangeDetectionStrategy.Default,
745 encapsulation: i0.ViewEncapsulation.None,
746 animations: [matSnackBarAnimations.snackBarState],
747 host: {
748 'class': 'mat-snack-bar-container',
749 '[@state]': '_animationState',
750 '(@state.done)': 'onAnimationEnd($event)'
751 },
752 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"]
753 },] }
754 ];
755 MatSnackBarContainer.ctorParameters = function () { return [
756 { type: i0.NgZone },
757 { type: i0.ElementRef },
758 { type: i0.ChangeDetectorRef },
759 { type: platform.Platform },
760 { type: MatSnackBarConfig }
761 ]; };
762 MatSnackBarContainer.propDecorators = {
763 _portalOutlet: [{ type: i0.ViewChild, args: [portal.CdkPortalOutlet, { static: true },] }]
764 };
765
766 /**
767 * @license
768 * Copyright Google LLC All Rights Reserved.
769 *
770 * Use of this source code is governed by an MIT-style license that can be
771 * found in the LICENSE file at https://angular.io/license
772 */
773 var MatSnackBarModule = /** @class */ (function () {
774 function MatSnackBarModule() {
775 }
776 return MatSnackBarModule;
777 }());
778 MatSnackBarModule.decorators = [
779 { type: i0.NgModule, args: [{
780 imports: [
781 i1.OverlayModule,
782 portal.PortalModule,
783 common.CommonModule,
784 button.MatButtonModule,
785 core.MatCommonModule,
786 ],
787 exports: [MatSnackBarContainer, core.MatCommonModule],
788 declarations: [MatSnackBarContainer, SimpleSnackBar],
789 entryComponents: [MatSnackBarContainer, SimpleSnackBar],
790 },] }
791 ];
792
793 /**
794 * @license
795 * Copyright Google LLC All Rights Reserved.
796 *
797 * Use of this source code is governed by an MIT-style license that can be
798 * found in the LICENSE file at https://angular.io/license
799 */
800 /** Injection token that can be used to specify default snack bar. */
801 var MAT_SNACK_BAR_DEFAULT_OPTIONS = new i0.InjectionToken('mat-snack-bar-default-options', {
802 providedIn: 'root',
803 factory: MAT_SNACK_BAR_DEFAULT_OPTIONS_FACTORY,
804 });
805 /** @docs-private */
806 function MAT_SNACK_BAR_DEFAULT_OPTIONS_FACTORY() {
807 return new MatSnackBarConfig();
808 }
809 /**
810 * Service to dispatch Material Design snack bar messages.
811 */
812 var MatSnackBar = /** @class */ (function () {
813 function MatSnackBar(_overlay, _live, _injector, _breakpointObserver, _parentSnackBar, _defaultConfig) {
814 this._overlay = _overlay;
815 this._live = _live;
816 this._injector = _injector;
817 this._breakpointObserver = _breakpointObserver;
818 this._parentSnackBar = _parentSnackBar;
819 this._defaultConfig = _defaultConfig;
820 /**
821 * Reference to the current snack bar in the view *at this level* (in the Angular injector tree).
822 * If there is a parent snack-bar service, all operations should delegate to that parent
823 * via `_openedSnackBarRef`.
824 */
825 this._snackBarRefAtThisLevel = null;
826 /** The component that should be rendered as the snack bar's simple component. */
827 this.simpleSnackBarComponent = SimpleSnackBar;
828 /** The container component that attaches the provided template or component. */
829 this.snackBarContainerComponent = MatSnackBarContainer;
830 /** The CSS class to apply for handset mode. */
831 this.handsetCssClass = 'mat-snack-bar-handset';
832 }
833 Object.defineProperty(MatSnackBar.prototype, "_openedSnackBarRef", {
834 /** Reference to the currently opened snackbar at *any* level. */
835 get: function () {
836 var parent = this._parentSnackBar;
837 return parent ? parent._openedSnackBarRef : this._snackBarRefAtThisLevel;
838 },
839 set: function (value) {
840 if (this._parentSnackBar) {
841 this._parentSnackBar._openedSnackBarRef = value;
842 }
843 else {
844 this._snackBarRefAtThisLevel = value;
845 }
846 },
847 enumerable: false,
848 configurable: true
849 });
850 /**
851 * Creates and dispatches a snack bar with a custom component for the content, removing any
852 * currently opened snack bars.
853 *
854 * @param component Component to be instantiated.
855 * @param config Extra configuration for the snack bar.
856 */
857 MatSnackBar.prototype.openFromComponent = function (component, config) {
858 return this._attach(component, config);
859 };
860 /**
861 * Creates and dispatches a snack bar with a custom template for the content, removing any
862 * currently opened snack bars.
863 *
864 * @param template Template to be instantiated.
865 * @param config Extra configuration for the snack bar.
866 */
867 MatSnackBar.prototype.openFromTemplate = function (template, config) {
868 return this._attach(template, config);
869 };
870 /**
871 * Opens a snackbar with a message and an optional action.
872 * @param message The message to show in the snackbar.
873 * @param action The label for the snackbar action.
874 * @param config Additional configuration options for the snackbar.
875 */
876 MatSnackBar.prototype.open = function (message, action, config) {
877 if (action === void 0) { action = ''; }
878 var _config = Object.assign(Object.assign({}, this._defaultConfig), config);
879 // Since the user doesn't have access to the component, we can
880 // override the data to pass in our own message and action.
881 _config.data = { message: message, action: action };
882 // Since the snack bar has `role="alert"`, we don't
883 // want to announce the same message twice.
884 if (_config.announcementMessage === message) {
885 _config.announcementMessage = undefined;
886 }
887 return this.openFromComponent(this.simpleSnackBarComponent, _config);
888 };
889 /**
890 * Dismisses the currently-visible snack bar.
891 */
892 MatSnackBar.prototype.dismiss = function () {
893 if (this._openedSnackBarRef) {
894 this._openedSnackBarRef.dismiss();
895 }
896 };
897 MatSnackBar.prototype.ngOnDestroy = function () {
898 // Only dismiss the snack bar at the current level on destroy.
899 if (this._snackBarRefAtThisLevel) {
900 this._snackBarRefAtThisLevel.dismiss();
901 }
902 };
903 /**
904 * Attaches the snack bar container component to the overlay.
905 */
906 MatSnackBar.prototype._attachSnackBarContainer = function (overlayRef, config) {
907 var userInjector = config && config.viewContainerRef && config.viewContainerRef.injector;
908 var injector = i0.Injector.create({
909 parent: userInjector || this._injector,
910 providers: [{ provide: MatSnackBarConfig, useValue: config }]
911 });
912 var containerPortal = new portal.ComponentPortal(this.snackBarContainerComponent, config.viewContainerRef, injector);
913 var containerRef = overlayRef.attach(containerPortal);
914 containerRef.instance.snackBarConfig = config;
915 return containerRef.instance;
916 };
917 /**
918 * Places a new component or a template as the content of the snack bar container.
919 */
920 MatSnackBar.prototype._attach = function (content, userConfig) {
921 var _this = this;
922 var config = Object.assign(Object.assign(Object.assign({}, new MatSnackBarConfig()), this._defaultConfig), userConfig);
923 var overlayRef = this._createOverlay(config);
924 var container = this._attachSnackBarContainer(overlayRef, config);
925 var snackBarRef = new MatSnackBarRef(container, overlayRef);
926 if (content instanceof i0.TemplateRef) {
927 var portal$1 = new portal.TemplatePortal(content, null, {
928 $implicit: config.data,
929 snackBarRef: snackBarRef
930 });
931 snackBarRef.instance = container.attachTemplatePortal(portal$1);
932 }
933 else {
934 var injector = this._createInjector(config, snackBarRef);
935 var portal$1 = new portal.ComponentPortal(content, undefined, injector);
936 var contentRef = container.attachComponentPortal(portal$1);
937 // We can't pass this via the injector, because the injector is created earlier.
938 snackBarRef.instance = contentRef.instance;
939 }
940 // Subscribe to the breakpoint observer and attach the mat-snack-bar-handset class as
941 // appropriate. This class is applied to the overlay element because the overlay must expand to
942 // fill the width of the screen for full width snackbars.
943 this._breakpointObserver.observe(i3.Breakpoints.HandsetPortrait).pipe(operators.takeUntil(overlayRef.detachments())).subscribe(function (state) {
944 var classList = overlayRef.overlayElement.classList;
945 state.matches ? classList.add(_this.handsetCssClass) : classList.remove(_this.handsetCssClass);
946 });
947 if (config.announcementMessage) {
948 // Wait until the snack bar contents have been announced then deliver this message.
949 container._onAnnounce.subscribe(function () {
950 _this._live.announce(config.announcementMessage, config.politeness);
951 });
952 }
953 this._animateSnackBar(snackBarRef, config);
954 this._openedSnackBarRef = snackBarRef;
955 return this._openedSnackBarRef;
956 };
957 /** Animates the old snack bar out and the new one in. */
958 MatSnackBar.prototype._animateSnackBar = function (snackBarRef, config) {
959 var _this = this;
960 // When the snackbar is dismissed, clear the reference to it.
961 snackBarRef.afterDismissed().subscribe(function () {
962 // Clear the snackbar ref if it hasn't already been replaced by a newer snackbar.
963 if (_this._openedSnackBarRef == snackBarRef) {
964 _this._openedSnackBarRef = null;
965 }
966 if (config.announcementMessage) {
967 _this._live.clear();
968 }
969 });
970 if (this._openedSnackBarRef) {
971 // If a snack bar is already in view, dismiss it and enter the
972 // new snack bar after exit animation is complete.
973 this._openedSnackBarRef.afterDismissed().subscribe(function () {
974 snackBarRef.containerInstance.enter();
975 });
976 this._openedSnackBarRef.dismiss();
977 }
978 else {
979 // If no snack bar is in view, enter the new snack bar.
980 snackBarRef.containerInstance.enter();
981 }
982 // If a dismiss timeout is provided, set up dismiss based on after the snackbar is opened.
983 if (config.duration && config.duration > 0) {
984 snackBarRef.afterOpened().subscribe(function () { return snackBarRef._dismissAfter(config.duration); });
985 }
986 };
987 /**
988 * Creates a new overlay and places it in the correct location.
989 * @param config The user-specified snack bar config.
990 */
991 MatSnackBar.prototype._createOverlay = function (config) {
992 var overlayConfig = new i1.OverlayConfig();
993 overlayConfig.direction = config.direction;
994 var positionStrategy = this._overlay.position().global();
995 // Set horizontal position.
996 var isRtl = config.direction === 'rtl';
997 var isLeft = (config.horizontalPosition === 'left' ||
998 (config.horizontalPosition === 'start' && !isRtl) ||
999 (config.horizontalPosition === 'end' && isRtl));
1000 var isRight = !isLeft && config.horizontalPosition !== 'center';
1001 if (isLeft) {
1002 positionStrategy.left('0');
1003 }
1004 else if (isRight) {
1005 positionStrategy.right('0');
1006 }
1007 else {
1008 positionStrategy.centerHorizontally();
1009 }
1010 // Set horizontal position.
1011 if (config.verticalPosition === 'top') {
1012 positionStrategy.top('0');
1013 }
1014 else {
1015 positionStrategy.bottom('0');
1016 }
1017 overlayConfig.positionStrategy = positionStrategy;
1018 return this._overlay.create(overlayConfig);
1019 };
1020 /**
1021 * Creates an injector to be used inside of a snack bar component.
1022 * @param config Config that was used to create the snack bar.
1023 * @param snackBarRef Reference to the snack bar.
1024 */
1025 MatSnackBar.prototype._createInjector = function (config, snackBarRef) {
1026 var userInjector = config && config.viewContainerRef && config.viewContainerRef.injector;
1027 return i0.Injector.create({
1028 parent: userInjector || this._injector,
1029 providers: [
1030 { provide: MatSnackBarRef, useValue: snackBarRef },
1031 { provide: MAT_SNACK_BAR_DATA, useValue: config.data }
1032 ]
1033 });
1034 };
1035 return MatSnackBar;
1036 }());
1037 MatSnackBar.ɵprov = i0__namespace.ɵɵdefineInjectable({ factory: function MatSnackBar_Factory() { return new MatSnackBar(i0__namespace.ɵɵinject(i1__namespace.Overlay), i0__namespace.ɵɵinject(i2__namespace.LiveAnnouncer), i0__namespace.ɵɵinject(i0__namespace.INJECTOR), i0__namespace.ɵɵinject(i3__namespace.BreakpointObserver), i0__namespace.ɵɵinject(MatSnackBar, 12), i0__namespace.ɵɵinject(MAT_SNACK_BAR_DEFAULT_OPTIONS)); }, token: MatSnackBar, providedIn: MatSnackBarModule });
1038 MatSnackBar.decorators = [
1039 { type: i0.Injectable, args: [{ providedIn: MatSnackBarModule },] }
1040 ];
1041 MatSnackBar.ctorParameters = function () { return [
1042 { type: i1.Overlay },
1043 { type: i2.LiveAnnouncer },
1044 { type: i0.Injector },
1045 { type: i3.BreakpointObserver },
1046 { type: MatSnackBar, decorators: [{ type: i0.Optional }, { type: i0.SkipSelf }] },
1047 { type: MatSnackBarConfig, decorators: [{ type: i0.Inject, args: [MAT_SNACK_BAR_DEFAULT_OPTIONS,] }] }
1048 ]; };
1049
1050 /**
1051 * @license
1052 * Copyright Google LLC All Rights Reserved.
1053 *
1054 * Use of this source code is governed by an MIT-style license that can be
1055 * found in the LICENSE file at https://angular.io/license
1056 */
1057
1058 /**
1059 * Generated bundle index. Do not edit.
1060 */
1061
1062 exports.MAT_SNACK_BAR_DATA = MAT_SNACK_BAR_DATA;
1063 exports.MAT_SNACK_BAR_DEFAULT_OPTIONS = MAT_SNACK_BAR_DEFAULT_OPTIONS;
1064 exports.MAT_SNACK_BAR_DEFAULT_OPTIONS_FACTORY = MAT_SNACK_BAR_DEFAULT_OPTIONS_FACTORY;
1065 exports.MatSnackBar = MatSnackBar;
1066 exports.MatSnackBarConfig = MatSnackBarConfig;
1067 exports.MatSnackBarContainer = MatSnackBarContainer;
1068 exports.MatSnackBarModule = MatSnackBarModule;
1069 exports.MatSnackBarRef = MatSnackBarRef;
1070 exports.SimpleSnackBar = SimpleSnackBar;
1071 exports.matSnackBarAnimations = matSnackBarAnimations;
1072
1073 Object.defineProperty(exports, '__esModule', { value: true });
1074
1075})));
1076//# sourceMappingURL=material-snack-bar.umd.js.map
Note: See TracBrowser for help on using the repository browser.