source: trip-planner-front/node_modules/@angular/material/bundles/material-button-toggle.umd.js@ 76712b2

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

initial commit
  • Property mode set to 100644
File size: 42.6 KB
Line 
1(function (global, factory) {
2 typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/cdk/a11y'), require('@angular/cdk/coercion'), require('@angular/cdk/collections'), require('@angular/core'), require('@angular/forms'), require('@angular/material/core')) :
3 typeof define === 'function' && define.amd ? define('@angular/material/button-toggle', ['exports', '@angular/cdk/a11y', '@angular/cdk/coercion', '@angular/cdk/collections', '@angular/core', '@angular/forms', '@angular/material/core'], factory) :
4 (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory((global.ng = global.ng || {}, global.ng.material = global.ng.material || {}, global.ng.material.buttonToggle = {}), global.ng.cdk.a11y, global.ng.cdk.coercion, global.ng.cdk.collections, global.ng.core, global.ng.forms, global.ng.material.core));
5}(this, (function (exports, a11y, coercion, collections, core, forms, core$1) { 'use strict';
6
7 /*! *****************************************************************************
8 Copyright (c) Microsoft Corporation.
9
10 Permission to use, copy, modify, and/or distribute this software for any
11 purpose with or without fee is hereby granted.
12
13 THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
14 REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
15 AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
16 INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
17 LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
18 OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
19 PERFORMANCE OF THIS SOFTWARE.
20 ***************************************************************************** */
21 /* global Reflect, Promise */
22 var extendStatics = function (d, b) {
23 extendStatics = Object.setPrototypeOf ||
24 ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
25 function (d, b) { for (var p in b)
26 if (Object.prototype.hasOwnProperty.call(b, p))
27 d[p] = b[p]; };
28 return extendStatics(d, b);
29 };
30 function __extends(d, b) {
31 if (typeof b !== "function" && b !== null)
32 throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
33 extendStatics(d, b);
34 function __() { this.constructor = d; }
35 d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
36 }
37 var __assign = function () {
38 __assign = Object.assign || function __assign(t) {
39 for (var s, i = 1, n = arguments.length; i < n; i++) {
40 s = arguments[i];
41 for (var p in s)
42 if (Object.prototype.hasOwnProperty.call(s, p))
43 t[p] = s[p];
44 }
45 return t;
46 };
47 return __assign.apply(this, arguments);
48 };
49 function __rest(s, e) {
50 var t = {};
51 for (var p in s)
52 if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
53 t[p] = s[p];
54 if (s != null && typeof Object.getOwnPropertySymbols === "function")
55 for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
56 if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
57 t[p[i]] = s[p[i]];
58 }
59 return t;
60 }
61 function __decorate(decorators, target, key, desc) {
62 var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
63 if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
64 r = Reflect.decorate(decorators, target, key, desc);
65 else
66 for (var i = decorators.length - 1; i >= 0; i--)
67 if (d = decorators[i])
68 r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
69 return c > 3 && r && Object.defineProperty(target, key, r), r;
70 }
71 function __param(paramIndex, decorator) {
72 return function (target, key) { decorator(target, key, paramIndex); };
73 }
74 function __metadata(metadataKey, metadataValue) {
75 if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
76 return Reflect.metadata(metadataKey, metadataValue);
77 }
78 function __awaiter(thisArg, _arguments, P, generator) {
79 function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
80 return new (P || (P = Promise))(function (resolve, reject) {
81 function fulfilled(value) { try {
82 step(generator.next(value));
83 }
84 catch (e) {
85 reject(e);
86 } }
87 function rejected(value) { try {
88 step(generator["throw"](value));
89 }
90 catch (e) {
91 reject(e);
92 } }
93 function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
94 step((generator = generator.apply(thisArg, _arguments || [])).next());
95 });
96 }
97 function __generator(thisArg, body) {
98 var _ = { label: 0, sent: function () { if (t[0] & 1)
99 throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
100 return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function () { return this; }), g;
101 function verb(n) { return function (v) { return step([n, v]); }; }
102 function step(op) {
103 if (f)
104 throw new TypeError("Generator is already executing.");
105 while (_)
106 try {
107 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)
108 return t;
109 if (y = 0, t)
110 op = [op[0] & 2, t.value];
111 switch (op[0]) {
112 case 0:
113 case 1:
114 t = op;
115 break;
116 case 4:
117 _.label++;
118 return { value: op[1], done: false };
119 case 5:
120 _.label++;
121 y = op[1];
122 op = [0];
123 continue;
124 case 7:
125 op = _.ops.pop();
126 _.trys.pop();
127 continue;
128 default:
129 if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
130 _ = 0;
131 continue;
132 }
133 if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) {
134 _.label = op[1];
135 break;
136 }
137 if (op[0] === 6 && _.label < t[1]) {
138 _.label = t[1];
139 t = op;
140 break;
141 }
142 if (t && _.label < t[2]) {
143 _.label = t[2];
144 _.ops.push(op);
145 break;
146 }
147 if (t[2])
148 _.ops.pop();
149 _.trys.pop();
150 continue;
151 }
152 op = body.call(thisArg, _);
153 }
154 catch (e) {
155 op = [6, e];
156 y = 0;
157 }
158 finally {
159 f = t = 0;
160 }
161 if (op[0] & 5)
162 throw op[1];
163 return { value: op[0] ? op[1] : void 0, done: true };
164 }
165 }
166 var __createBinding = Object.create ? (function (o, m, k, k2) {
167 if (k2 === undefined)
168 k2 = k;
169 Object.defineProperty(o, k2, { enumerable: true, get: function () { return m[k]; } });
170 }) : (function (o, m, k, k2) {
171 if (k2 === undefined)
172 k2 = k;
173 o[k2] = m[k];
174 });
175 function __exportStar(m, o) {
176 for (var p in m)
177 if (p !== "default" && !Object.prototype.hasOwnProperty.call(o, p))
178 __createBinding(o, m, p);
179 }
180 function __values(o) {
181 var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
182 if (m)
183 return m.call(o);
184 if (o && typeof o.length === "number")
185 return {
186 next: function () {
187 if (o && i >= o.length)
188 o = void 0;
189 return { value: o && o[i++], done: !o };
190 }
191 };
192 throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
193 }
194 function __read(o, n) {
195 var m = typeof Symbol === "function" && o[Symbol.iterator];
196 if (!m)
197 return o;
198 var i = m.call(o), r, ar = [], e;
199 try {
200 while ((n === void 0 || n-- > 0) && !(r = i.next()).done)
201 ar.push(r.value);
202 }
203 catch (error) {
204 e = { error: error };
205 }
206 finally {
207 try {
208 if (r && !r.done && (m = i["return"]))
209 m.call(i);
210 }
211 finally {
212 if (e)
213 throw e.error;
214 }
215 }
216 return ar;
217 }
218 /** @deprecated */
219 function __spread() {
220 for (var ar = [], i = 0; i < arguments.length; i++)
221 ar = ar.concat(__read(arguments[i]));
222 return ar;
223 }
224 /** @deprecated */
225 function __spreadArrays() {
226 for (var s = 0, i = 0, il = arguments.length; i < il; i++)
227 s += arguments[i].length;
228 for (var r = Array(s), k = 0, i = 0; i < il; i++)
229 for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
230 r[k] = a[j];
231 return r;
232 }
233 function __spreadArray(to, from, pack) {
234 if (pack || arguments.length === 2)
235 for (var i = 0, l = from.length, ar; i < l; i++) {
236 if (ar || !(i in from)) {
237 if (!ar)
238 ar = Array.prototype.slice.call(from, 0, i);
239 ar[i] = from[i];
240 }
241 }
242 return to.concat(ar || from);
243 }
244 function __await(v) {
245 return this instanceof __await ? (this.v = v, this) : new __await(v);
246 }
247 function __asyncGenerator(thisArg, _arguments, generator) {
248 if (!Symbol.asyncIterator)
249 throw new TypeError("Symbol.asyncIterator is not defined.");
250 var g = generator.apply(thisArg, _arguments || []), i, q = [];
251 return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
252 function verb(n) { if (g[n])
253 i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
254 function resume(n, v) { try {
255 step(g[n](v));
256 }
257 catch (e) {
258 settle(q[0][3], e);
259 } }
260 function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
261 function fulfill(value) { resume("next", value); }
262 function reject(value) { resume("throw", value); }
263 function settle(f, v) { if (f(v), q.shift(), q.length)
264 resume(q[0][0], q[0][1]); }
265 }
266 function __asyncDelegator(o) {
267 var i, p;
268 return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
269 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; }
270 }
271 function __asyncValues(o) {
272 if (!Symbol.asyncIterator)
273 throw new TypeError("Symbol.asyncIterator is not defined.");
274 var m = o[Symbol.asyncIterator], i;
275 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);
276 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); }); }; }
277 function settle(resolve, reject, d, v) { Promise.resolve(v).then(function (v) { resolve({ value: v, done: d }); }, reject); }
278 }
279 function __makeTemplateObject(cooked, raw) {
280 if (Object.defineProperty) {
281 Object.defineProperty(cooked, "raw", { value: raw });
282 }
283 else {
284 cooked.raw = raw;
285 }
286 return cooked;
287 }
288 ;
289 var __setModuleDefault = Object.create ? (function (o, v) {
290 Object.defineProperty(o, "default", { enumerable: true, value: v });
291 }) : function (o, v) {
292 o["default"] = v;
293 };
294 function __importStar(mod) {
295 if (mod && mod.__esModule)
296 return mod;
297 var result = {};
298 if (mod != null)
299 for (var k in mod)
300 if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k))
301 __createBinding(result, mod, k);
302 __setModuleDefault(result, mod);
303 return result;
304 }
305 function __importDefault(mod) {
306 return (mod && mod.__esModule) ? mod : { default: mod };
307 }
308 function __classPrivateFieldGet(receiver, state, kind, f) {
309 if (kind === "a" && !f)
310 throw new TypeError("Private accessor was defined without a getter");
311 if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
312 throw new TypeError("Cannot read private member from an object whose class did not declare it");
313 return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
314 }
315 function __classPrivateFieldSet(receiver, state, value, kind, f) {
316 if (kind === "m")
317 throw new TypeError("Private method is not writable");
318 if (kind === "a" && !f)
319 throw new TypeError("Private accessor was defined without a setter");
320 if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
321 throw new TypeError("Cannot write private member to an object whose class did not declare it");
322 return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
323 }
324
325 /**
326 * Injection token that can be used to configure the
327 * default options for all button toggles within an app.
328 */
329 var MAT_BUTTON_TOGGLE_DEFAULT_OPTIONS = new core.InjectionToken('MAT_BUTTON_TOGGLE_DEFAULT_OPTIONS');
330 /**
331 * Injection token that can be used to reference instances of `MatButtonToggleGroup`.
332 * It serves as alternative token to the actual `MatButtonToggleGroup` class which
333 * could cause unnecessary retention of the class and its component metadata.
334 */
335 var MAT_BUTTON_TOGGLE_GROUP = new core.InjectionToken('MatButtonToggleGroup');
336 /**
337 * Provider Expression that allows mat-button-toggle-group to register as a ControlValueAccessor.
338 * This allows it to support [(ngModel)].
339 * @docs-private
340 */
341 var MAT_BUTTON_TOGGLE_GROUP_VALUE_ACCESSOR = {
342 provide: forms.NG_VALUE_ACCESSOR,
343 useExisting: core.forwardRef(function () { return MatButtonToggleGroup; }),
344 multi: true
345 };
346 // Counter used to generate unique IDs.
347 var uniqueIdCounter = 0;
348 /** Change event object emitted by MatButtonToggle. */
349 var MatButtonToggleChange = /** @class */ (function () {
350 function MatButtonToggleChange(
351 /** The MatButtonToggle that emits the event. */
352 source,
353 /** The value assigned to the MatButtonToggle. */
354 value) {
355 this.source = source;
356 this.value = value;
357 }
358 return MatButtonToggleChange;
359 }());
360 /** Exclusive selection button toggle group that behaves like a radio-button group. */
361 var MatButtonToggleGroup = /** @class */ (function () {
362 function MatButtonToggleGroup(_changeDetector, defaultOptions) {
363 this._changeDetector = _changeDetector;
364 this._vertical = false;
365 this._multiple = false;
366 this._disabled = false;
367 /**
368 * The method to be called in order to update ngModel.
369 * Now `ngModel` binding is not supported in multiple selection mode.
370 */
371 this._controlValueAccessorChangeFn = function () { };
372 /** onTouch function registered via registerOnTouch (ControlValueAccessor). */
373 this._onTouched = function () { };
374 this._name = "mat-button-toggle-group-" + uniqueIdCounter++;
375 /**
376 * Event that emits whenever the value of the group changes.
377 * Used to facilitate two-way data binding.
378 * @docs-private
379 */
380 this.valueChange = new core.EventEmitter();
381 /** Event emitted when the group's value changes. */
382 this.change = new core.EventEmitter();
383 this.appearance =
384 defaultOptions && defaultOptions.appearance ? defaultOptions.appearance : 'standard';
385 }
386 Object.defineProperty(MatButtonToggleGroup.prototype, "name", {
387 /** `name` attribute for the underlying `input` element. */
388 get: function () { return this._name; },
389 set: function (value) {
390 var _this = this;
391 this._name = value;
392 if (this._buttonToggles) {
393 this._buttonToggles.forEach(function (toggle) {
394 toggle.name = _this._name;
395 toggle._markForCheck();
396 });
397 }
398 },
399 enumerable: false,
400 configurable: true
401 });
402 Object.defineProperty(MatButtonToggleGroup.prototype, "vertical", {
403 /** Whether the toggle group is vertical. */
404 get: function () { return this._vertical; },
405 set: function (value) {
406 this._vertical = coercion.coerceBooleanProperty(value);
407 },
408 enumerable: false,
409 configurable: true
410 });
411 Object.defineProperty(MatButtonToggleGroup.prototype, "value", {
412 /** Value of the toggle group. */
413 get: function () {
414 var selected = this._selectionModel ? this._selectionModel.selected : [];
415 if (this.multiple) {
416 return selected.map(function (toggle) { return toggle.value; });
417 }
418 return selected[0] ? selected[0].value : undefined;
419 },
420 set: function (newValue) {
421 this._setSelectionByValue(newValue);
422 this.valueChange.emit(this.value);
423 },
424 enumerable: false,
425 configurable: true
426 });
427 Object.defineProperty(MatButtonToggleGroup.prototype, "selected", {
428 /** Selected button toggles in the group. */
429 get: function () {
430 var selected = this._selectionModel ? this._selectionModel.selected : [];
431 return this.multiple ? selected : (selected[0] || null);
432 },
433 enumerable: false,
434 configurable: true
435 });
436 Object.defineProperty(MatButtonToggleGroup.prototype, "multiple", {
437 /** Whether multiple button toggles can be selected. */
438 get: function () { return this._multiple; },
439 set: function (value) {
440 this._multiple = coercion.coerceBooleanProperty(value);
441 },
442 enumerable: false,
443 configurable: true
444 });
445 Object.defineProperty(MatButtonToggleGroup.prototype, "disabled", {
446 /** Whether multiple button toggle group is disabled. */
447 get: function () { return this._disabled; },
448 set: function (value) {
449 this._disabled = coercion.coerceBooleanProperty(value);
450 if (this._buttonToggles) {
451 this._buttonToggles.forEach(function (toggle) { return toggle._markForCheck(); });
452 }
453 },
454 enumerable: false,
455 configurable: true
456 });
457 MatButtonToggleGroup.prototype.ngOnInit = function () {
458 this._selectionModel = new collections.SelectionModel(this.multiple, undefined, false);
459 };
460 MatButtonToggleGroup.prototype.ngAfterContentInit = function () {
461 var _a;
462 (_a = this._selectionModel).select.apply(_a, __spreadArray([], __read(this._buttonToggles.filter(function (toggle) { return toggle.checked; }))));
463 };
464 /**
465 * Sets the model value. Implemented as part of ControlValueAccessor.
466 * @param value Value to be set to the model.
467 */
468 MatButtonToggleGroup.prototype.writeValue = function (value) {
469 this.value = value;
470 this._changeDetector.markForCheck();
471 };
472 // Implemented as part of ControlValueAccessor.
473 MatButtonToggleGroup.prototype.registerOnChange = function (fn) {
474 this._controlValueAccessorChangeFn = fn;
475 };
476 // Implemented as part of ControlValueAccessor.
477 MatButtonToggleGroup.prototype.registerOnTouched = function (fn) {
478 this._onTouched = fn;
479 };
480 // Implemented as part of ControlValueAccessor.
481 MatButtonToggleGroup.prototype.setDisabledState = function (isDisabled) {
482 this.disabled = isDisabled;
483 };
484 /** Dispatch change event with current selection and group value. */
485 MatButtonToggleGroup.prototype._emitChangeEvent = function () {
486 var selected = this.selected;
487 var source = Array.isArray(selected) ? selected[selected.length - 1] : selected;
488 var event = new MatButtonToggleChange(source, this.value);
489 this._controlValueAccessorChangeFn(event.value);
490 this.change.emit(event);
491 };
492 /**
493 * Syncs a button toggle's selected state with the model value.
494 * @param toggle Toggle to be synced.
495 * @param select Whether the toggle should be selected.
496 * @param isUserInput Whether the change was a result of a user interaction.
497 * @param deferEvents Whether to defer emitting the change events.
498 */
499 MatButtonToggleGroup.prototype._syncButtonToggle = function (toggle, select, isUserInput, deferEvents) {
500 var _this = this;
501 if (isUserInput === void 0) { isUserInput = false; }
502 if (deferEvents === void 0) { deferEvents = false; }
503 // Deselect the currently-selected toggle, if we're in single-selection
504 // mode and the button being toggled isn't selected at the moment.
505 if (!this.multiple && this.selected && !toggle.checked) {
506 this.selected.checked = false;
507 }
508 if (this._selectionModel) {
509 if (select) {
510 this._selectionModel.select(toggle);
511 }
512 else {
513 this._selectionModel.deselect(toggle);
514 }
515 }
516 else {
517 deferEvents = true;
518 }
519 // We need to defer in some cases in order to avoid "changed after checked errors", however
520 // the side-effect is that we may end up updating the model value out of sequence in others
521 // The `deferEvents` flag allows us to decide whether to do it on a case-by-case basis.
522 if (deferEvents) {
523 Promise.resolve().then(function () { return _this._updateModelValue(isUserInput); });
524 }
525 else {
526 this._updateModelValue(isUserInput);
527 }
528 };
529 /** Checks whether a button toggle is selected. */
530 MatButtonToggleGroup.prototype._isSelected = function (toggle) {
531 return this._selectionModel && this._selectionModel.isSelected(toggle);
532 };
533 /** Determines whether a button toggle should be checked on init. */
534 MatButtonToggleGroup.prototype._isPrechecked = function (toggle) {
535 if (typeof this._rawValue === 'undefined') {
536 return false;
537 }
538 if (this.multiple && Array.isArray(this._rawValue)) {
539 return this._rawValue.some(function (value) { return toggle.value != null && value === toggle.value; });
540 }
541 return toggle.value === this._rawValue;
542 };
543 /** Updates the selection state of the toggles in the group based on a value. */
544 MatButtonToggleGroup.prototype._setSelectionByValue = function (value) {
545 var _this = this;
546 this._rawValue = value;
547 if (!this._buttonToggles) {
548 return;
549 }
550 if (this.multiple && value) {
551 if (!Array.isArray(value) && (typeof ngDevMode === 'undefined' || ngDevMode)) {
552 throw Error('Value must be an array in multiple-selection mode.');
553 }
554 this._clearSelection();
555 value.forEach(function (currentValue) { return _this._selectValue(currentValue); });
556 }
557 else {
558 this._clearSelection();
559 this._selectValue(value);
560 }
561 };
562 /** Clears the selected toggles. */
563 MatButtonToggleGroup.prototype._clearSelection = function () {
564 this._selectionModel.clear();
565 this._buttonToggles.forEach(function (toggle) { return toggle.checked = false; });
566 };
567 /** Selects a value if there's a toggle that corresponds to it. */
568 MatButtonToggleGroup.prototype._selectValue = function (value) {
569 var correspondingOption = this._buttonToggles.find(function (toggle) {
570 return toggle.value != null && toggle.value === value;
571 });
572 if (correspondingOption) {
573 correspondingOption.checked = true;
574 this._selectionModel.select(correspondingOption);
575 }
576 };
577 /** Syncs up the group's value with the model and emits the change event. */
578 MatButtonToggleGroup.prototype._updateModelValue = function (isUserInput) {
579 // Only emit the change event for user input.
580 if (isUserInput) {
581 this._emitChangeEvent();
582 }
583 // Note: we emit this one no matter whether it was a user interaction, because
584 // it is used by Angular to sync up the two-way data binding.
585 this.valueChange.emit(this.value);
586 };
587 return MatButtonToggleGroup;
588 }());
589 MatButtonToggleGroup.decorators = [
590 { type: core.Directive, args: [{
591 selector: 'mat-button-toggle-group',
592 providers: [
593 MAT_BUTTON_TOGGLE_GROUP_VALUE_ACCESSOR,
594 { provide: MAT_BUTTON_TOGGLE_GROUP, useExisting: MatButtonToggleGroup },
595 ],
596 host: {
597 'role': 'group',
598 'class': 'mat-button-toggle-group',
599 '[attr.aria-disabled]': 'disabled',
600 '[class.mat-button-toggle-vertical]': 'vertical',
601 '[class.mat-button-toggle-group-appearance-standard]': 'appearance === "standard"',
602 },
603 exportAs: 'matButtonToggleGroup',
604 },] }
605 ];
606 MatButtonToggleGroup.ctorParameters = function () { return [
607 { type: core.ChangeDetectorRef },
608 { type: undefined, decorators: [{ type: core.Optional }, { type: core.Inject, args: [MAT_BUTTON_TOGGLE_DEFAULT_OPTIONS,] }] }
609 ]; };
610 MatButtonToggleGroup.propDecorators = {
611 _buttonToggles: [{ type: core.ContentChildren, args: [core.forwardRef(function () { return MatButtonToggle; }), {
612 // Note that this would technically pick up toggles
613 // from nested groups, but that's not a case that we support.
614 descendants: true
615 },] }],
616 appearance: [{ type: core.Input }],
617 name: [{ type: core.Input }],
618 vertical: [{ type: core.Input }],
619 value: [{ type: core.Input }],
620 valueChange: [{ type: core.Output }],
621 multiple: [{ type: core.Input }],
622 disabled: [{ type: core.Input }],
623 change: [{ type: core.Output }]
624 };
625 // Boilerplate for applying mixins to the MatButtonToggle class.
626 /** @docs-private */
627 var _MatButtonToggleBase = core$1.mixinDisableRipple(/** @class */ (function () {
628 function class_1() {
629 }
630 return class_1;
631 }()));
632 /** Single button inside of a toggle group. */
633 var MatButtonToggle = /** @class */ (function (_super) {
634 __extends(MatButtonToggle, _super);
635 function MatButtonToggle(toggleGroup, _changeDetectorRef, _elementRef, _focusMonitor, defaultTabIndex, defaultOptions) {
636 var _this = _super.call(this) || this;
637 _this._changeDetectorRef = _changeDetectorRef;
638 _this._elementRef = _elementRef;
639 _this._focusMonitor = _focusMonitor;
640 _this._isSingleSelector = false;
641 _this._checked = false;
642 /**
643 * Users can specify the `aria-labelledby` attribute which will be forwarded to the input element
644 */
645 _this.ariaLabelledby = null;
646 _this._disabled = false;
647 /** Event emitted when the group value changes. */
648 _this.change = new core.EventEmitter();
649 var parsedTabIndex = Number(defaultTabIndex);
650 _this.tabIndex = (parsedTabIndex || parsedTabIndex === 0) ? parsedTabIndex : null;
651 _this.buttonToggleGroup = toggleGroup;
652 _this.appearance =
653 defaultOptions && defaultOptions.appearance ? defaultOptions.appearance : 'standard';
654 return _this;
655 }
656 Object.defineProperty(MatButtonToggle.prototype, "buttonId", {
657 /** Unique ID for the underlying `button` element. */
658 get: function () { return this.id + "-button"; },
659 enumerable: false,
660 configurable: true
661 });
662 Object.defineProperty(MatButtonToggle.prototype, "appearance", {
663 /** The appearance style of the button. */
664 get: function () {
665 return this.buttonToggleGroup ? this.buttonToggleGroup.appearance : this._appearance;
666 },
667 set: function (value) {
668 this._appearance = value;
669 },
670 enumerable: false,
671 configurable: true
672 });
673 Object.defineProperty(MatButtonToggle.prototype, "checked", {
674 /** Whether the button is checked. */
675 get: function () {
676 return this.buttonToggleGroup ? this.buttonToggleGroup._isSelected(this) : this._checked;
677 },
678 set: function (value) {
679 var newValue = coercion.coerceBooleanProperty(value);
680 if (newValue !== this._checked) {
681 this._checked = newValue;
682 if (this.buttonToggleGroup) {
683 this.buttonToggleGroup._syncButtonToggle(this, this._checked);
684 }
685 this._changeDetectorRef.markForCheck();
686 }
687 },
688 enumerable: false,
689 configurable: true
690 });
691 Object.defineProperty(MatButtonToggle.prototype, "disabled", {
692 /** Whether the button is disabled. */
693 get: function () {
694 return this._disabled || (this.buttonToggleGroup && this.buttonToggleGroup.disabled);
695 },
696 set: function (value) { this._disabled = coercion.coerceBooleanProperty(value); },
697 enumerable: false,
698 configurable: true
699 });
700 MatButtonToggle.prototype.ngOnInit = function () {
701 var group = this.buttonToggleGroup;
702 this._isSingleSelector = group && !group.multiple;
703 this.id = this.id || "mat-button-toggle-" + uniqueIdCounter++;
704 if (this._isSingleSelector) {
705 this.name = group.name;
706 }
707 if (group) {
708 if (group._isPrechecked(this)) {
709 this.checked = true;
710 }
711 else if (group._isSelected(this) !== this._checked) {
712 // As as side effect of the circular dependency between the toggle group and the button,
713 // we may end up in a state where the button is supposed to be checked on init, but it
714 // isn't, because the checked value was assigned too early. This can happen when Ivy
715 // assigns the static input value before the `ngOnInit` has run.
716 group._syncButtonToggle(this, this._checked);
717 }
718 }
719 };
720 MatButtonToggle.prototype.ngAfterViewInit = function () {
721 this._focusMonitor.monitor(this._elementRef, true);
722 };
723 MatButtonToggle.prototype.ngOnDestroy = function () {
724 var group = this.buttonToggleGroup;
725 this._focusMonitor.stopMonitoring(this._elementRef);
726 // Remove the toggle from the selection once it's destroyed. Needs to happen
727 // on the next tick in order to avoid "changed after checked" errors.
728 if (group && group._isSelected(this)) {
729 group._syncButtonToggle(this, false, false, true);
730 }
731 };
732 /** Focuses the button. */
733 MatButtonToggle.prototype.focus = function (options) {
734 this._buttonElement.nativeElement.focus(options);
735 };
736 /** Checks the button toggle due to an interaction with the underlying native button. */
737 MatButtonToggle.prototype._onButtonClick = function () {
738 var newChecked = this._isSingleSelector ? true : !this._checked;
739 if (newChecked !== this._checked) {
740 this._checked = newChecked;
741 if (this.buttonToggleGroup) {
742 this.buttonToggleGroup._syncButtonToggle(this, this._checked, true);
743 this.buttonToggleGroup._onTouched();
744 }
745 }
746 // Emit a change event when it's the single selector
747 this.change.emit(new MatButtonToggleChange(this, this.value));
748 };
749 /**
750 * Marks the button toggle as needing checking for change detection.
751 * This method is exposed because the parent button toggle group will directly
752 * update bound properties of the radio button.
753 */
754 MatButtonToggle.prototype._markForCheck = function () {
755 // When the group value changes, the button will not be notified.
756 // Use `markForCheck` to explicit update button toggle's status.
757 this._changeDetectorRef.markForCheck();
758 };
759 return MatButtonToggle;
760 }(_MatButtonToggleBase));
761 MatButtonToggle.decorators = [
762 { type: core.Component, args: [{
763 selector: 'mat-button-toggle',
764 template: "<button #button class=\"mat-button-toggle-button mat-focus-indicator\"\n type=\"button\"\n [id]=\"buttonId\"\n [attr.tabindex]=\"disabled ? -1 : tabIndex\"\n [attr.aria-pressed]=\"checked\"\n [disabled]=\"disabled || null\"\n [attr.name]=\"name || null\"\n [attr.aria-label]=\"ariaLabel\"\n [attr.aria-labelledby]=\"ariaLabelledby\"\n (click)=\"_onButtonClick()\">\n <span class=\"mat-button-toggle-label-content\">\n <ng-content></ng-content>\n </span>\n</button>\n\n<span class=\"mat-button-toggle-focus-overlay\"></span>\n<span class=\"mat-button-toggle-ripple\" matRipple\n [matRippleTrigger]=\"button\"\n [matRippleDisabled]=\"this.disableRipple || this.disabled\">\n</span>\n",
765 encapsulation: core.ViewEncapsulation.None,
766 exportAs: 'matButtonToggle',
767 changeDetection: core.ChangeDetectionStrategy.OnPush,
768 inputs: ['disableRipple'],
769 host: {
770 '[class.mat-button-toggle-standalone]': '!buttonToggleGroup',
771 '[class.mat-button-toggle-checked]': 'checked',
772 '[class.mat-button-toggle-disabled]': 'disabled',
773 '[class.mat-button-toggle-appearance-standard]': 'appearance === "standard"',
774 'class': 'mat-button-toggle',
775 '[attr.aria-label]': 'null',
776 '[attr.aria-labelledby]': 'null',
777 '[attr.id]': 'id',
778 '[attr.name]': 'null',
779 '(focus)': 'focus()',
780 'role': 'presentation',
781 },
782 styles: [".mat-button-toggle-standalone,.mat-button-toggle-group{position:relative;display:inline-flex;flex-direction:row;white-space:nowrap;overflow:hidden;border-radius:2px;-webkit-tap-highlight-color:transparent}.cdk-high-contrast-active .mat-button-toggle-standalone,.cdk-high-contrast-active .mat-button-toggle-group{outline:solid 1px}.mat-button-toggle-standalone.mat-button-toggle-appearance-standard,.mat-button-toggle-group-appearance-standard{border-radius:4px}.cdk-high-contrast-active .mat-button-toggle-standalone.mat-button-toggle-appearance-standard,.cdk-high-contrast-active .mat-button-toggle-group-appearance-standard{outline:0}.mat-button-toggle-vertical{flex-direction:column}.mat-button-toggle-vertical .mat-button-toggle-label-content{display:block}.mat-button-toggle{white-space:nowrap;position:relative}.mat-button-toggle .mat-icon svg{vertical-align:top}.mat-button-toggle.cdk-keyboard-focused .mat-button-toggle-focus-overlay{opacity:1}.cdk-high-contrast-active .mat-button-toggle.cdk-keyboard-focused .mat-button-toggle-focus-overlay{opacity:.5}.mat-button-toggle-appearance-standard:not(.mat-button-toggle-disabled):hover .mat-button-toggle-focus-overlay{opacity:.04}.mat-button-toggle-appearance-standard.cdk-keyboard-focused:not(.mat-button-toggle-disabled) .mat-button-toggle-focus-overlay{opacity:.12}.cdk-high-contrast-active .mat-button-toggle-appearance-standard.cdk-keyboard-focused:not(.mat-button-toggle-disabled) .mat-button-toggle-focus-overlay{opacity:.5}@media(hover: none){.mat-button-toggle-appearance-standard:not(.mat-button-toggle-disabled):hover .mat-button-toggle-focus-overlay{display:none}}.mat-button-toggle-label-content{-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;display:inline-block;line-height:36px;padding:0 16px;position:relative}.mat-button-toggle-appearance-standard .mat-button-toggle-label-content{padding:0 12px}.mat-button-toggle-label-content>*{vertical-align:middle}.mat-button-toggle-focus-overlay{border-radius:inherit;pointer-events:none;opacity:0;top:0;left:0;right:0;bottom:0;position:absolute}.mat-button-toggle-checked .mat-button-toggle-focus-overlay{border-bottom:solid 36px}.cdk-high-contrast-active .mat-button-toggle-checked .mat-button-toggle-focus-overlay{opacity:.5;height:0}.cdk-high-contrast-active .mat-button-toggle-checked.mat-button-toggle-appearance-standard .mat-button-toggle-focus-overlay{border-bottom:solid 500px}.mat-button-toggle .mat-button-toggle-ripple{top:0;left:0;right:0;bottom:0;position:absolute;pointer-events:none}.mat-button-toggle-button{border:0;background:none;color:inherit;padding:0;margin:0;font:inherit;outline:none;width:100%;cursor:pointer}.mat-button-toggle-disabled .mat-button-toggle-button{cursor:default}.mat-button-toggle-button::-moz-focus-inner{border:0}\n"]
783 },] }
784 ];
785 MatButtonToggle.ctorParameters = function () { return [
786 { type: MatButtonToggleGroup, decorators: [{ type: core.Optional }, { type: core.Inject, args: [MAT_BUTTON_TOGGLE_GROUP,] }] },
787 { type: core.ChangeDetectorRef },
788 { type: core.ElementRef },
789 { type: a11y.FocusMonitor },
790 { type: String, decorators: [{ type: core.Attribute, args: ['tabindex',] }] },
791 { type: undefined, decorators: [{ type: core.Optional }, { type: core.Inject, args: [MAT_BUTTON_TOGGLE_DEFAULT_OPTIONS,] }] }
792 ]; };
793 MatButtonToggle.propDecorators = {
794 ariaLabel: [{ type: core.Input, args: ['aria-label',] }],
795 ariaLabelledby: [{ type: core.Input, args: ['aria-labelledby',] }],
796 _buttonElement: [{ type: core.ViewChild, args: ['button',] }],
797 id: [{ type: core.Input }],
798 name: [{ type: core.Input }],
799 value: [{ type: core.Input }],
800 tabIndex: [{ type: core.Input }],
801 appearance: [{ type: core.Input }],
802 checked: [{ type: core.Input }],
803 disabled: [{ type: core.Input }],
804 change: [{ type: core.Output }]
805 };
806
807 /**
808 * @license
809 * Copyright Google LLC All Rights Reserved.
810 *
811 * Use of this source code is governed by an MIT-style license that can be
812 * found in the LICENSE file at https://angular.io/license
813 */
814 var MatButtonToggleModule = /** @class */ (function () {
815 function MatButtonToggleModule() {
816 }
817 return MatButtonToggleModule;
818 }());
819 MatButtonToggleModule.decorators = [
820 { type: core.NgModule, args: [{
821 imports: [core$1.MatCommonModule, core$1.MatRippleModule],
822 exports: [core$1.MatCommonModule, MatButtonToggleGroup, MatButtonToggle],
823 declarations: [MatButtonToggleGroup, MatButtonToggle],
824 },] }
825 ];
826
827 /**
828 * @license
829 * Copyright Google LLC All Rights Reserved.
830 *
831 * Use of this source code is governed by an MIT-style license that can be
832 * found in the LICENSE file at https://angular.io/license
833 */
834
835 /**
836 * Generated bundle index. Do not edit.
837 */
838
839 exports.MAT_BUTTON_TOGGLE_DEFAULT_OPTIONS = MAT_BUTTON_TOGGLE_DEFAULT_OPTIONS;
840 exports.MAT_BUTTON_TOGGLE_GROUP = MAT_BUTTON_TOGGLE_GROUP;
841 exports.MAT_BUTTON_TOGGLE_GROUP_VALUE_ACCESSOR = MAT_BUTTON_TOGGLE_GROUP_VALUE_ACCESSOR;
842 exports.MatButtonToggle = MatButtonToggle;
843 exports.MatButtonToggleChange = MatButtonToggleChange;
844 exports.MatButtonToggleGroup = MatButtonToggleGroup;
845 exports.MatButtonToggleModule = MatButtonToggleModule;
846
847 Object.defineProperty(exports, '__esModule', { value: true });
848
849})));
850//# sourceMappingURL=material-button-toggle.umd.js.map
Note: See TracBrowser for help on using the repository browser.