/**
* @license
* Copyright Google LLC All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://angular.io/license
*/
import { FocusKeyManager, FocusMonitor } from '@angular/cdk/a11y';
import { coerceBooleanProperty } from '@angular/cdk/coercion';
import { SelectionModel } from '@angular/cdk/collections';
import { A, DOWN_ARROW, ENTER, hasModifierKey, SPACE, UP_ARROW, } from '@angular/cdk/keycodes';
import { Attribute, ChangeDetectionStrategy, ChangeDetectorRef, Component, ContentChild, ContentChildren, ElementRef, EventEmitter, forwardRef, Inject, Input, Output, QueryList, ViewChild, ViewEncapsulation, } from '@angular/core';
import { NG_VALUE_ACCESSOR } from '@angular/forms';
import { MatLine, mixinDisableRipple, setLines, } from '@angular/material/core';
import { Subject } from 'rxjs';
import { startWith, takeUntil } from 'rxjs/operators';
import { MatListAvatarCssMatStyler, MatListIconCssMatStyler } from './list';
const _MatSelectionListBase = mixinDisableRipple(class {
});
const _MatListOptionBase = mixinDisableRipple(class {
});
/** @docs-private */
export const MAT_SELECTION_LIST_VALUE_ACCESSOR = {
provide: NG_VALUE_ACCESSOR,
useExisting: forwardRef(() => MatSelectionList),
multi: true
};
/** Change event that is being fired whenever the selected state of an option changes. */
export class MatSelectionListChange {
constructor(
/** Reference to the selection list that emitted the event. */
source,
/**
* Reference to the option that has been changed.
* @deprecated Use `options` instead, because some events may change more than one option.
* @breaking-change 12.0.0
*/
option,
/** Reference to the options that have been changed. */
options) {
this.source = source;
this.option = option;
this.options = options;
}
}
/**
* Component for list-options of selection-list. Each list-option can automatically
* generate a checkbox and can put current item into the selectionModel of selection-list
* if the current item is selected.
*/
export class MatListOption extends _MatListOptionBase {
constructor(_element, _changeDetector,
/** @docs-private */
selectionList) {
super();
this._element = _element;
this._changeDetector = _changeDetector;
this.selectionList = selectionList;
this._selected = false;
this._disabled = false;
this._hasFocus = false;
/**
* Emits when the selected state of the option has changed.
* Use to facilitate two-data binding to the `selected` property.
* @docs-private
*/
this.selectedChange = new EventEmitter();
/** Whether the label should appear before or after the checkbox. Defaults to 'after' */
this.checkboxPosition = 'after';
/**
* This is set to true after the first OnChanges cycle so we don't clear the value of `selected`
* in the first cycle.
*/
this._inputsInitialized = false;
}
/** Theme color of the list option. This sets the color of the checkbox. */
get color() { return this._color || this.selectionList.color; }
set color(newValue) { this._color = newValue; }
/** Value of the option */
get value() { return this._value; }
set value(newValue) {
if (this.selected &&
!this.selectionList.compareWith(newValue, this.value) &&
this._inputsInitialized) {
this.selected = false;
}
this._value = newValue;
}
/** Whether the option is disabled. */
get disabled() { return this._disabled || (this.selectionList && this.selectionList.disabled); }
set disabled(value) {
const newValue = coerceBooleanProperty(value);
if (newValue !== this._disabled) {
this._disabled = newValue;
this._changeDetector.markForCheck();
}
}
/** Whether the option is selected. */
get selected() { return this.selectionList.selectedOptions.isSelected(this); }
set selected(value) {
const isSelected = coerceBooleanProperty(value);
if (isSelected !== this._selected) {
this._setSelected(isSelected);
if (isSelected || this.selectionList.multiple) {
this.selectionList._reportValueChange();
}
}
}
ngOnInit() {
const list = this.selectionList;
if (list._value && list._value.some(value => list.compareWith(value, this._value))) {
this._setSelected(true);
}
const wasSelected = this._selected;
// List options that are selected at initialization can't be reported properly to the form
// control. This is because it takes some time until the selection-list knows about all
// available options. Also it can happen that the ControlValueAccessor has an initial value
// that should be used instead. Deferring the value change report to the next tick ensures
// that the form control value is not being overwritten.
Promise.resolve().then(() => {
if (this._selected || wasSelected) {
this.selected = true;
this._changeDetector.markForCheck();
}
});
this._inputsInitialized = true;
}
ngAfterContentInit() {
setLines(this._lines, this._element);
}
ngOnDestroy() {
if (this.selected) {
// We have to delay this until the next tick in order
// to avoid changed after checked errors.
Promise.resolve().then(() => {
this.selected = false;
});
}
const hadFocus = this._hasFocus;
const newActiveItem = this.selectionList._removeOptionFromList(this);
// Only move focus if this option was focused at the time it was destroyed.
if (hadFocus && newActiveItem) {
newActiveItem.focus();
}
}
/** Toggles the selection state of the option. */
toggle() {
this.selected = !this.selected;
}
/** Allows for programmatic focusing of the option. */
focus() {
this._element.nativeElement.focus();
}
/**
* Returns the list item's text label. Implemented as a part of the FocusKeyManager.
* @docs-private
*/
getLabel() {
return this._text ? (this._text.nativeElement.textContent || '') : '';
}
/** Whether this list item should show a ripple effect when clicked. */
_isRippleDisabled() {
return this.disabled || this.disableRipple || this.selectionList.disableRipple;
}
_handleClick() {
if (!this.disabled && (this.selectionList.multiple || !this.selected)) {
this.toggle();
// Emit a change event if the selected state of the option changed through user interaction.
this.selectionList._emitChangeEvent([this]);
}
}
_handleFocus() {
this.selectionList._setFocusedOption(this);
this._hasFocus = true;
}
_handleBlur() {
this.selectionList._onTouched();
this._hasFocus = false;
}
/** Retrieves the DOM element of the component host. */
_getHostElement() {
return this._element.nativeElement;
}
/** Sets the selected state of the option. Returns whether the value has changed. */
_setSelected(selected) {
if (selected === this._selected) {
return false;
}
this._selected = selected;
if (selected) {
this.selectionList.selectedOptions.select(this);
}
else {
this.selectionList.selectedOptions.deselect(this);
}
this.selectedChange.emit(selected);
this._changeDetector.markForCheck();
return true;
}
/**
* Notifies Angular that the option needs to be checked in the next change detection run. Mainly
* used to trigger an update of the list option if the disabled state of the selection list
* changed.
*/
_markForCheck() {
this._changeDetector.markForCheck();
}
}
MatListOption.decorators = [
{ type: Component, args: [{
selector: 'mat-list-option',
exportAs: 'matListOption',
inputs: ['disableRipple'],
host: {
'role': 'option',
'class': 'mat-list-item mat-list-option mat-focus-indicator',
'(focus)': '_handleFocus()',
'(blur)': '_handleBlur()',
'(click)': '_handleClick()',
'[class.mat-list-item-disabled]': 'disabled',
'[class.mat-list-item-with-avatar]': '_avatar || _icon',
// Manually set the "primary" or "warn" class if the color has been explicitly
// set to "primary" or "warn". The pseudo checkbox picks up these classes for
// its theme.
'[class.mat-primary]': 'color === "primary"',
// Even though accent is the default, we need to set this class anyway, because the list might
// be placed inside a parent that has one of the other colors with a higher specificity.
'[class.mat-accent]': 'color !== "primary" && color !== "warn"',
'[class.mat-warn]': 'color === "warn"',
'[class.mat-list-single-selected-option]': 'selected && !selectionList.multiple',
'[attr.aria-selected]': 'selected',
'[attr.aria-disabled]': 'disabled',
'[attr.tabindex]': '-1',
},
template: "\n\n
\n\n
\n\n
\n\n \n \n\n