@angular/material
Version:
Angular Material
283 lines • 39.1 kB
JavaScript
/**
* @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 { coerceBooleanProperty, coerceNumberProperty } from '@angular/cdk/coercion';
import { Platform } from '@angular/cdk/platform';
import { ContentChildren, Directive, ElementRef, inject, Inject, Input, NgZone, Optional, QueryList, } from '@angular/core';
import { MAT_RIPPLE_GLOBAL_OPTIONS, RippleRenderer, } from '@angular/material/core';
import { ANIMATION_MODULE_TYPE } from '@angular/platform-browser/animations';
import { Subscription, merge } from 'rxjs';
import { MatListItemIcon, MatListItemAvatar, } from './list-item-sections';
import { MAT_LIST_CONFIG } from './tokens';
import * as i0 from "@angular/core";
import * as i1 from "@angular/cdk/platform";
/** @docs-private */
export class MatListBase {
constructor() {
this._isNonInteractive = true;
this._disableRipple = false;
this._disabled = false;
this._defaultOptions = inject(MAT_LIST_CONFIG, { optional: true });
}
/** Whether ripples for all list items is disabled. */
get disableRipple() {
return this._disableRipple;
}
set disableRipple(value) {
this._disableRipple = coerceBooleanProperty(value);
}
/**
* Whether the entire list is disabled. When disabled, the list itself and each of its list items
* are disabled.
*/
get disabled() {
return this._disabled;
}
set disabled(value) {
this._disabled = coerceBooleanProperty(value);
}
static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.0", ngImport: i0, type: MatListBase, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.0.0", type: MatListBase, inputs: { disableRipple: "disableRipple", disabled: "disabled" }, host: { properties: { "attr.aria-disabled": "disabled" } }, ngImport: i0 }); }
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.0", ngImport: i0, type: MatListBase, decorators: [{
type: Directive,
args: [{
host: {
'[attr.aria-disabled]': 'disabled',
},
}]
}], propDecorators: { disableRipple: [{
type: Input
}], disabled: [{
type: Input
}] } });
/** @docs-private */
export class MatListItemBase {
/**
* The number of lines this list item should reserve space for. If not specified,
* lines are inferred based on the projected content.
*
* Explicitly specifying the number of lines is useful if you want to acquire additional
* space and enable the wrapping of text. The unscoped text content of a list item will
* always be able to take up the remaining space of the item, unless it represents the title.
*
* A maximum of three lines is supported as per the Material Design specification.
*/
set lines(lines) {
this._explicitLines = coerceNumberProperty(lines, null);
this._updateItemLines(false);
}
/** Whether ripples for list items are disabled. */
get disableRipple() {
return (this.disabled ||
this._disableRipple ||
this._noopAnimations ||
!!this._listBase?.disableRipple);
}
set disableRipple(value) {
this._disableRipple = coerceBooleanProperty(value);
}
/** Whether the list-item is disabled. */
get disabled() {
return this._disabled || !!this._listBase?.disabled;
}
set disabled(value) {
this._disabled = coerceBooleanProperty(value);
}
/**
* Implemented as part of `RippleTarget`.
* @docs-private
*/
get rippleDisabled() {
return this.disableRipple || !!this.rippleConfig.disabled;
}
constructor(_elementRef, _ngZone, _listBase, _platform, globalRippleOptions, animationMode) {
this._elementRef = _elementRef;
this._ngZone = _ngZone;
this._listBase = _listBase;
this._platform = _platform;
this._explicitLines = null;
this._disableRipple = false;
this._disabled = false;
this._subscriptions = new Subscription();
this._rippleRenderer = null;
/** Whether the list item has unscoped text content. */
this._hasUnscopedTextContent = false;
this.rippleConfig = globalRippleOptions || {};
this._hostElement = this._elementRef.nativeElement;
this._isButtonElement = this._hostElement.nodeName.toLowerCase() === 'button';
this._noopAnimations = animationMode === 'NoopAnimations';
if (_listBase && !_listBase._isNonInteractive) {
this._initInteractiveListItem();
}
// If no type attribute is specified for a host `<button>` element, set it to `button`. If a
// type attribute is already specified, we do nothing. We do this for backwards compatibility.
// TODO: Determine if we intend to continue doing this for the MDC-based list.
if (this._isButtonElement && !this._hostElement.hasAttribute('type')) {
this._hostElement.setAttribute('type', 'button');
}
}
ngAfterViewInit() {
this._monitorProjectedLinesAndTitle();
this._updateItemLines(true);
}
ngOnDestroy() {
this._subscriptions.unsubscribe();
if (this._rippleRenderer !== null) {
this._rippleRenderer._removeTriggerEvents();
}
}
/** Whether the list item has icons or avatars. */
_hasIconOrAvatar() {
return !!(this._avatars.length || this._icons.length);
}
_initInteractiveListItem() {
this._hostElement.classList.add('mat-mdc-list-item-interactive');
this._rippleRenderer = new RippleRenderer(this, this._ngZone, this._hostElement, this._platform);
this._rippleRenderer.setupTriggerEvents(this._hostElement);
}
/**
* Subscribes to changes in the projected title and lines. Triggers a
* item lines update whenever a change occurs.
*/
_monitorProjectedLinesAndTitle() {
this._ngZone.runOutsideAngular(() => {
this._subscriptions.add(merge(this._lines.changes, this._titles.changes).subscribe(() => this._updateItemLines(false)));
});
}
/**
* Updates the lines of the list item. Based on the projected user content and optional
* explicit lines setting, the visual appearance of the list item is determined.
*
* This method should be invoked whenever the projected user content changes, or
* when the explicit lines have been updated.
*
* @param recheckUnscopedContent Whether the projected unscoped content should be re-checked.
* The unscoped content is not re-checked for every update as it is a rather expensive check
* for content that is expected to not change very often.
*/
_updateItemLines(recheckUnscopedContent) {
// If the updated is triggered too early before the view and content is initialized,
// we just skip the update. After view initialization the update is triggered again.
if (!this._lines || !this._titles || !this._unscopedContent) {
return;
}
// Re-check the DOM for unscoped text content if requested. This needs to
// happen before any computation or sanity checks run as these rely on the
// result of whether there is unscoped text content or not.
if (recheckUnscopedContent) {
this._checkDomForUnscopedTextContent();
}
// Sanity check the list item lines and title in the content. This is a dev-mode only
// check that can be dead-code eliminated by Terser in production.
if (typeof ngDevMode === 'undefined' || ngDevMode) {
sanityCheckListItemContent(this);
}
const numberOfLines = this._explicitLines ?? this._inferLinesFromContent();
const unscopedContentEl = this._unscopedContent.nativeElement;
// Update the list item element to reflect the number of lines.
this._hostElement.classList.toggle('mat-mdc-list-item-single-line', numberOfLines <= 1);
this._hostElement.classList.toggle('mdc-list-item--with-one-line', numberOfLines <= 1);
this._hostElement.classList.toggle('mdc-list-item--with-two-lines', numberOfLines === 2);
this._hostElement.classList.toggle('mdc-list-item--with-three-lines', numberOfLines === 3);
// If there is no title and the unscoped content is the is the only line, the
// unscoped text content will be treated as the title of the list-item.
if (this._hasUnscopedTextContent) {
const treatAsTitle = this._titles.length === 0 && numberOfLines === 1;
unscopedContentEl.classList.toggle('mdc-list-item__primary-text', treatAsTitle);
unscopedContentEl.classList.toggle('mdc-list-item__secondary-text', !treatAsTitle);
}
else {
unscopedContentEl.classList.remove('mdc-list-item__primary-text');
unscopedContentEl.classList.remove('mdc-list-item__secondary-text');
}
}
/**
* Infers the number of lines based on the projected user content. This is useful
* if no explicit number of lines has been specified on the list item.
*
* The number of lines is inferred based on whether there is a title, the number of
* additional lines (secondary/tertiary). An additional line is acquired if there is
* unscoped text content.
*/
_inferLinesFromContent() {
let numOfLines = this._titles.length + this._lines.length;
if (this._hasUnscopedTextContent) {
numOfLines += 1;
}
return numOfLines;
}
/** Checks whether the list item has unscoped text content. */
_checkDomForUnscopedTextContent() {
this._hasUnscopedTextContent = Array.from(this._unscopedContent.nativeElement.childNodes)
.filter(node => node.nodeType !== node.COMMENT_NODE)
.some(node => !!(node.textContent && node.textContent.trim()));
}
static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.0", ngImport: i0, type: MatListItemBase, deps: [{ token: i0.ElementRef }, { token: i0.NgZone }, { token: MatListBase, optional: true }, { token: i1.Platform }, { token: MAT_RIPPLE_GLOBAL_OPTIONS, optional: true }, { token: ANIMATION_MODULE_TYPE, optional: true }], target: i0.ɵɵFactoryTarget.Directive }); }
static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.0.0", type: MatListItemBase, inputs: { lines: "lines", disableRipple: "disableRipple", disabled: "disabled" }, host: { properties: { "class.mdc-list-item--disabled": "disabled", "attr.aria-disabled": "disabled", "attr.disabled": "(_isButtonElement && disabled) || null" } }, queries: [{ propertyName: "_avatars", predicate: MatListItemAvatar }, { propertyName: "_icons", predicate: MatListItemIcon }], ngImport: i0 }); }
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.0", ngImport: i0, type: MatListItemBase, decorators: [{
type: Directive,
args: [{
host: {
'[class.mdc-list-item--disabled]': 'disabled',
'[attr.aria-disabled]': 'disabled',
'[attr.disabled]': '(_isButtonElement && disabled) || null',
},
}]
}], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.NgZone }, { type: MatListBase, decorators: [{
type: Optional
}] }, { type: i1.Platform }, { type: undefined, decorators: [{
type: Optional
}, {
type: Inject,
args: [MAT_RIPPLE_GLOBAL_OPTIONS]
}] }, { type: undefined, decorators: [{
type: Optional
}, {
type: Inject,
args: [ANIMATION_MODULE_TYPE]
}] }], propDecorators: { _avatars: [{
type: ContentChildren,
args: [MatListItemAvatar, { descendants: false }]
}], _icons: [{
type: ContentChildren,
args: [MatListItemIcon, { descendants: false }]
}], lines: [{
type: Input
}], disableRipple: [{
type: Input
}], disabled: [{
type: Input
}] } });
/**
* Sanity checks the configuration of the list item with respect to the amount
* of lines, whether there is a title, or if there is unscoped text content.
*
* The checks are extracted into a top-level function that can be dead-code
* eliminated by Terser or other optimizers in production mode.
*/
function sanityCheckListItemContent(item) {
const numTitles = item._titles.length;
const numLines = item._titles.length;
if (numTitles > 1) {
throw Error('A list item cannot have multiple titles.');
}
if (numTitles === 0 && numLines > 0) {
throw Error('A list item line can only be used if there is a list item title.');
}
if (numTitles === 0 &&
item._hasUnscopedTextContent &&
item._explicitLines !== null &&
item._explicitLines > 1) {
throw Error('A list item cannot have wrapping content without a title.');
}
if (numLines > 2 || (numLines === 2 && item._hasUnscopedTextContent)) {
throw Error('A list item can have at maximum three lines.');
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"list-base.js","sourceRoot":"","sources":["../../../../../../src/material/list/list-base.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {BooleanInput, coerceBooleanProperty, coerceNumberProperty} from '@angular/cdk/coercion';\nimport {Platform} from '@angular/cdk/platform';\nimport {\n  AfterViewInit,\n  ContentChildren,\n  Directive,\n  ElementRef,\n  inject,\n  Inject,\n  Input,\n  NgZone,\n  OnDestroy,\n  Optional,\n  QueryList,\n} from '@angular/core';\nimport {\n  MAT_RIPPLE_GLOBAL_OPTIONS,\n  RippleConfig,\n  RippleGlobalOptions,\n  RippleRenderer,\n  RippleTarget,\n} from '@angular/material/core';\nimport {ANIMATION_MODULE_TYPE} from '@angular/platform-browser/animations';\nimport {Subscription, merge} from 'rxjs';\nimport {\n  MatListItemLine,\n  MatListItemTitle,\n  MatListItemIcon,\n  MatListItemAvatar,\n} from './list-item-sections';\nimport {MAT_LIST_CONFIG} from './tokens';\n\n@Directive({\n  host: {\n    '[attr.aria-disabled]': 'disabled',\n  },\n})\n/** @docs-private */\nexport abstract class MatListBase {\n  _isNonInteractive: boolean = true;\n\n  /** Whether ripples for all list items is disabled. */\n  @Input()\n  get disableRipple(): boolean {\n    return this._disableRipple;\n  }\n  set disableRipple(value: BooleanInput) {\n    this._disableRipple = coerceBooleanProperty(value);\n  }\n  private _disableRipple: boolean = false;\n\n  /**\n   * Whether the entire list is disabled. When disabled, the list itself and each of its list items\n   * are disabled.\n   */\n  @Input()\n  get disabled(): boolean {\n    return this._disabled;\n  }\n  set disabled(value: BooleanInput) {\n    this._disabled = coerceBooleanProperty(value);\n  }\n  private _disabled = false;\n\n  protected _defaultOptions = inject(MAT_LIST_CONFIG, {optional: true});\n}\n\n@Directive({\n  host: {\n    '[class.mdc-list-item--disabled]': 'disabled',\n    '[attr.aria-disabled]': 'disabled',\n    '[attr.disabled]': '(_isButtonElement && disabled) || null',\n  },\n})\n/** @docs-private */\nexport abstract class MatListItemBase implements AfterViewInit, OnDestroy, RippleTarget {\n  /** Query list matching list-item line elements. */\n  abstract _lines: QueryList<MatListItemLine> | undefined;\n\n  /** Query list matching list-item title elements. */\n  abstract _titles: QueryList<MatListItemTitle> | undefined;\n\n  /**\n   * Element reference to the unscoped content in a list item.\n   *\n   * Unscoped content is user-projected text content in a list item that is\n   * not part of an explicit line or title.\n   */\n  abstract _unscopedContent: ElementRef<HTMLSpanElement> | undefined;\n\n  /** Host element for the list item. */\n  _hostElement: HTMLElement;\n\n  /** indicate whether the host element is a button or not */\n  _isButtonElement: boolean;\n\n  /** Whether animations are disabled. */\n  _noopAnimations: boolean;\n\n  @ContentChildren(MatListItemAvatar, {descendants: false}) _avatars: QueryList<never>;\n  @ContentChildren(MatListItemIcon, {descendants: false}) _icons: QueryList<never>;\n\n  /**\n   * The number of lines this list item should reserve space for. If not specified,\n   * lines are inferred based on the projected content.\n   *\n   * Explicitly specifying the number of lines is useful if you want to acquire additional\n   * space and enable the wrapping of text. The unscoped text content of a list item will\n   * always be able to take up the remaining space of the item, unless it represents the title.\n   *\n   * A maximum of three lines is supported as per the Material Design specification.\n   */\n  @Input()\n  set lines(lines: number | string | null) {\n    this._explicitLines = coerceNumberProperty(lines, null);\n    this._updateItemLines(false);\n  }\n  _explicitLines: number | null = null;\n\n  /** Whether ripples for list items are disabled. */\n  @Input()\n  get disableRipple(): boolean {\n    return (\n      this.disabled ||\n      this._disableRipple ||\n      this._noopAnimations ||\n      !!this._listBase?.disableRipple\n    );\n  }\n  set disableRipple(value: BooleanInput) {\n    this._disableRipple = coerceBooleanProperty(value);\n  }\n  private _disableRipple: boolean = false;\n\n  /** Whether the list-item is disabled. */\n  @Input()\n  get disabled(): boolean {\n    return this._disabled || !!this._listBase?.disabled;\n  }\n  set disabled(value: BooleanInput) {\n    this._disabled = coerceBooleanProperty(value);\n  }\n  private _disabled = false;\n\n  private _subscriptions = new Subscription();\n  private _rippleRenderer: RippleRenderer | null = null;\n\n  /** Whether the list item has unscoped text content. */\n  _hasUnscopedTextContent: boolean = false;\n\n  /**\n   * Implemented as part of `RippleTarget`.\n   * @docs-private\n   */\n  rippleConfig: RippleConfig & RippleGlobalOptions;\n\n  /**\n   * Implemented as part of `RippleTarget`.\n   * @docs-private\n   */\n  get rippleDisabled(): boolean {\n    return this.disableRipple || !!this.rippleConfig.disabled;\n  }\n\n  constructor(\n    public _elementRef: ElementRef<HTMLElement>,\n    protected _ngZone: NgZone,\n    @Optional() private _listBase: MatListBase | null,\n    private _platform: Platform,\n    @Optional()\n    @Inject(MAT_RIPPLE_GLOBAL_OPTIONS)\n    globalRippleOptions?: RippleGlobalOptions,\n    @Optional() @Inject(ANIMATION_MODULE_TYPE) animationMode?: string,\n  ) {\n    this.rippleConfig = globalRippleOptions || {};\n    this._hostElement = this._elementRef.nativeElement;\n    this._isButtonElement = this._hostElement.nodeName.toLowerCase() === 'button';\n    this._noopAnimations = animationMode === 'NoopAnimations';\n\n    if (_listBase && !_listBase._isNonInteractive) {\n      this._initInteractiveListItem();\n    }\n\n    // If no type attribute is specified for a host `<button>` element, set it to `button`. If a\n    // type attribute is already specified, we do nothing. We do this for backwards compatibility.\n    // TODO: Determine if we intend to continue doing this for the MDC-based list.\n    if (this._isButtonElement && !this._hostElement.hasAttribute('type')) {\n      this._hostElement.setAttribute('type', 'button');\n    }\n  }\n\n  ngAfterViewInit() {\n    this._monitorProjectedLinesAndTitle();\n    this._updateItemLines(true);\n  }\n\n  ngOnDestroy() {\n    this._subscriptions.unsubscribe();\n    if (this._rippleRenderer !== null) {\n      this._rippleRenderer._removeTriggerEvents();\n    }\n  }\n\n  /** Whether the list item has icons or avatars. */\n  _hasIconOrAvatar() {\n    return !!(this._avatars.length || this._icons.length);\n  }\n\n  private _initInteractiveListItem() {\n    this._hostElement.classList.add('mat-mdc-list-item-interactive');\n    this._rippleRenderer = new RippleRenderer(\n      this,\n      this._ngZone,\n      this._hostElement,\n      this._platform,\n    );\n    this._rippleRenderer.setupTriggerEvents(this._hostElement);\n  }\n\n  /**\n   * Subscribes to changes in the projected title and lines. Triggers a\n   * item lines update whenever a change occurs.\n   */\n  private _monitorProjectedLinesAndTitle() {\n    this._ngZone.runOutsideAngular(() => {\n      this._subscriptions.add(\n        merge(this._lines!.changes, this._titles!.changes).subscribe(() =>\n          this._updateItemLines(false),\n        ),\n      );\n    });\n  }\n\n  /**\n   * Updates the lines of the list item. Based on the projected user content and optional\n   * explicit lines setting, the visual appearance of the list item is determined.\n   *\n   * This method should be invoked whenever the projected user content changes, or\n   * when the explicit lines have been updated.\n   *\n   * @param recheckUnscopedContent Whether the projected unscoped content should be re-checked.\n   *   The unscoped content is not re-checked for every update as it is a rather expensive check\n   *   for content that is expected to not change very often.\n   */\n  _updateItemLines(recheckUnscopedContent: boolean) {\n    // If the updated is triggered too early before the view and content is initialized,\n    // we just skip the update. After view initialization the update is triggered again.\n    if (!this._lines || !this._titles || !this._unscopedContent) {\n      return;\n    }\n\n    // Re-check the DOM for unscoped text content if requested. This needs to\n    // happen before any computation or sanity checks run as these rely on the\n    // result of whether there is unscoped text content or not.\n    if (recheckUnscopedContent) {\n      this._checkDomForUnscopedTextContent();\n    }\n\n    // Sanity check the list item lines and title in the content. This is a dev-mode only\n    // check that can be dead-code eliminated by Terser in production.\n    if (typeof ngDevMode === 'undefined' || ngDevMode) {\n      sanityCheckListItemContent(this);\n    }\n\n    const numberOfLines = this._explicitLines ?? this._inferLinesFromContent();\n    const unscopedContentEl = this._unscopedContent.nativeElement;\n\n    // Update the list item element to reflect the number of lines.\n    this._hostElement.classList.toggle('mat-mdc-list-item-single-line', numberOfLines <= 1);\n    this._hostElement.classList.toggle('mdc-list-item--with-one-line', numberOfLines <= 1);\n    this._hostElement.classList.toggle('mdc-list-item--with-two-lines', numberOfLines === 2);\n    this._hostElement.classList.toggle('mdc-list-item--with-three-lines', numberOfLines === 3);\n\n    // If there is no title and the unscoped content is the is the only line, the\n    // unscoped text content will be treated as the title of the list-item.\n    if (this._hasUnscopedTextContent) {\n      const treatAsTitle = this._titles.length === 0 && numberOfLines === 1;\n      unscopedContentEl.classList.toggle('mdc-list-item__primary-text', treatAsTitle);\n      unscopedContentEl.classList.toggle('mdc-list-item__secondary-text', !treatAsTitle);\n    } else {\n      unscopedContentEl.classList.remove('mdc-list-item__primary-text');\n      unscopedContentEl.classList.remove('mdc-list-item__secondary-text');\n    }\n  }\n\n  /**\n   * Infers the number of lines based on the projected user content. This is useful\n   * if no explicit number of lines has been specified on the list item.\n   *\n   * The number of lines is inferred based on whether there is a title, the number of\n   * additional lines (secondary/tertiary). An additional line is acquired if there is\n   * unscoped text content.\n   */\n  private _inferLinesFromContent() {\n    let numOfLines = this._titles!.length + this._lines!.length;\n    if (this._hasUnscopedTextContent) {\n      numOfLines += 1;\n    }\n    return numOfLines;\n  }\n\n  /** Checks whether the list item has unscoped text content. */\n  private _checkDomForUnscopedTextContent() {\n    this._hasUnscopedTextContent = Array.from<ChildNode>(\n      this._unscopedContent!.nativeElement.childNodes,\n    )\n      .filter(node => node.nodeType !== node.COMMENT_NODE)\n      .some(node => !!(node.textContent && node.textContent.trim()));\n  }\n}\n\n/**\n * Sanity checks the configuration of the list item with respect to the amount\n * of lines, whether there is a title, or if there is unscoped text content.\n *\n * The checks are extracted into a top-level function that can be dead-code\n * eliminated by Terser or other optimizers in production mode.\n */\nfunction sanityCheckListItemContent(item: MatListItemBase) {\n  const numTitles = item._titles!.length;\n  const numLines = item._titles!.length;\n\n  if (numTitles > 1) {\n    throw Error('A list item cannot have multiple titles.');\n  }\n  if (numTitles === 0 && numLines > 0) {\n    throw Error('A list item line can only be used if there is a list item title.');\n  }\n  if (\n    numTitles === 0 &&\n    item._hasUnscopedTextContent &&\n    item._explicitLines !== null &&\n    item._explicitLines > 1\n  ) {\n    throw Error('A list item cannot have wrapping content without a title.');\n  }\n  if (numLines > 2 || (numLines === 2 && item._hasUnscopedTextContent)) {\n    throw Error('A list item can have at maximum three lines.');\n  }\n}\n"]}