@angular/material 16.1.6 → 16.1.8

package/button/index.d.ts

@@ -12,7 +12,6 @@ import * as i4 from '@angular/material/core';
 import { InjectionToken } from '@angular/core';
 import { MatRipple } from '@angular/material/core';
 import { NgZone } from '@angular/core';
-import { OnChanges } from '@angular/core';
 import { OnDestroy } from '@angular/core';
 import { OnInit } from '@angular/core';
 import { Platform } from '@angular/cdk/platform';
@@ -95,7 +94,7 @@ export declare class MatButton extends MatButtonBase {
 }
 
 /** Base class for all buttons.  */
-declare class MatButtonBase extends _MatButtonMixin implements CanDisable, CanColor, CanDisableRipple, AfterViewInit, OnChanges, OnDestroy {
+declare class MatButtonBase extends _MatButtonMixin implements CanDisable, CanColor, CanDisableRipple, AfterViewInit, OnDestroy {
     _platform: Platform;
     _ngZone: NgZone;
     _animationMode?: string | undefined;
@@ -114,25 +113,30 @@ declare class MatButtonBase extends _MatButtonMixin implements CanDisable, CanCo
      */
     get ripple(): MatRipple;
     set ripple(v: MatRipple);
-    /** @docs-private Reference to the MatRipple instance of the button. */
-    protected _ripple?: MatRipple;
+    /** Whether the ripple effect is disabled or not. */
+    get disableRipple(): boolean;
+    set disableRipple(value: any);
+    private _disableRipple;
+    get disabled(): boolean;
+    set disabled(value: any);
+    private _disabled;
     constructor(elementRef: ElementRef, _platform: Platform, _ngZone: NgZone, _animationMode?: string | undefined);
     ngAfterViewInit(): void;
-    ngOnChanges(): void;
     ngOnDestroy(): void;
     /** Focuses the button. */
     focus(_origin?: FocusOrigin, options?: FocusOptions): void;
     /** Gets whether the button has one of the given attributes. */
     private _hasHostAttributes;
+    private _updateRippleDisabled;
     static ɵfac: i0.ɵɵFactoryDeclaration<MatButtonBase, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<MatButtonBase, never, never, {}, {}, never, never, false, never>;
 }
 
 /**
- * Handles attaching the MatButton's ripple on demand.
+ * Handles attaching ripples on demand.
  *
- * This service allows us to avoid eagerly creating & attaching the MatButton's ripple.
- * It works by creating & attaching the ripple only when a MatButton is first interacted with.
+ * This service allows us to avoid eagerly creating & attaching MatRipples.
+ * It works by creating & attaching a ripple only when a component is first interacted with.
  */
 declare class MatButtonLazyLoader implements OnDestroy {
     private _document;
@@ -142,11 +146,26 @@ declare class MatButtonLazyLoader implements OnDestroy {
     private _ngZone;
     constructor();
     ngOnDestroy(): void;
-    /** Handles creating and attaching button internals when a button is initially interacted with. */
+    /**
+     * Configures the ripple that will be rendered by the ripple loader.
+     *
+     * Stores the given information about how the ripple should be configured on the host
+     * element so that it can later be retrived & used when the ripple is actually created.
+     */
+    configureRipple(host: HTMLElement, config: {
+        className?: string;
+        centered?: boolean;
+        disabled?: boolean;
+    }): void;
+    /** Returns the ripple instance for the given host element. */
+    getRipple(host: HTMLElement): MatRipple | undefined;
+    /** Sets the disabled state on the ripple instance corresponding to the given host element. */
+    setDisabled(host: HTMLElement, disabled: boolean): void;
+    /** Handles creating and attaching component internals when a component it is initially interacted with. */
     private _onInteraction;
-    /** Creates a MatButtonRipple and appends it to the given button element. */
-    private _appendRipple;
-    _createMatRipple(button: HTMLElement): MatRipple | undefined;
+    /** Creates a MatRipple and appends it to the given element. */
+    createRipple(host: HTMLElement): MatRipple | undefined;
+    attachRipple(host: Element, ripple: MatRipple): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<MatButtonLazyLoader, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<MatButtonLazyLoader>;
 }
@@ -222,12 +241,6 @@ export declare class MatIconAnchor extends MatAnchorBase {
  * See https://material.io/develop/web/components/buttons/icon-buttons/
  */
 export declare class MatIconButton extends MatButtonBase {
-    /**
-     * Reference to the MatRipple instance of the button.
-     * @deprecated Considered an implementation detail. To be removed.
-     * @breaking-change 17.0.0
-     */
-    get ripple(): MatRipple;
     constructor(elementRef: ElementRef, platform: Platform, ngZone: NgZone, animationMode?: string);
     static ɵfac: i0.ɵɵFactoryDeclaration<MatIconButton, [null, null, null, { optional: true; }]>;
     static ɵcmp: i0.ɵɵComponentDeclaration<MatIconButton, "button[mat-icon-button]", ["matButton"], { "disabled": { "alias": "disabled"; "required": false; }; "disableRipple": { "alias": "disableRipple"; "required": false; }; "color": { "alias": "color"; "required": false; }; }, {}, never, ["*"], false, never>;

package/core/selection/pseudo-checkbox/_pseudo-checkbox-common.scss

@@ -42,7 +42,7 @@ $padding: checkbox-common.$border-width * 2;
 // `$box-size`: size of the checkbox.
 // `$border-size`: size of the checkbox's border.
 @mixin _checkbox-indeterminate-styles-with-size($box-size, $border-size) {
-  // Center the line in the the checkbox. `$checkbox-common.$border-width` is the width of the line.
+  // Center the line in the checkbox. `$checkbox-common.$border-width` is the width of the line.
   top: math.div($box-size - checkbox-common.$border-width, 2) - $border-size;
   width: $box-size - checkbox-common.$border-width - (2 * $border-size);
 }

package/core/tokens/m2/mat/_grid-list.scss

@@ -0,0 +1,46 @@
+@use '../../token-utils';
+@use '../../../typography/typography-utils';
+@use '../../../style/sass-utils';
+
+// The prefix used to generate the fully qualified name for tokens in this file.
+$prefix: (mat, grid-list);
+
+// Tokens that can't be configured through Angular Material's current theming API,
+// but may be in a future version of the theming API.
+@function get-unthemable-tokens() {
+  @return ();
+}
+
+// Tokens that can be configured through Angular Material's color theming API.
+@function get-color-tokens($config) {
+  @return ();
+}
+
+// Tokens that can be configured through Angular Material's typography theming API.
+@function get-typography-tokens($config) {
+  @return (
+    // TODO(crisbeto): other components have tokens for all typography dimensions.
+    // Here we only set the font size to maintain the same appearance as the pre-tokens
+    // theming API. Consider adding more tokens for letter spacing, font weight etc.
+    tile-header-primary-text-size: typography-utils.font-size($config, body-1),
+    tile-header-secondary-text-size: typography-utils.font-size($config, caption),
+    tile-footer-primary-text-size: typography-utils.font-size($config, body-1),
+    tile-footer-secondary-text-size: typography-utils.font-size($config, caption),
+  );
+}
+
+// Tokens that can be configured through Angular Material's density theming API.
+@function get-density-tokens($config) {
+  @return ();
+}
+
+// Combines the tokens generated by the above functions into a single map with placeholder values.
+// This is used to create token slots.
+@function get-token-slots() {
+  @return sass-utils.deep-merge-all(
+      get-unthemable-tokens(),
+      get-color-tokens(token-utils.$placeholder-color-config),
+      get-typography-tokens(token-utils.$placeholder-typography-config),
+      get-density-tokens(token-utils.$placeholder-density-config)
+  );
+}

package/core/tokens/m2/mdc/_circular-progress.scss

@@ -16,7 +16,7 @@ $prefix: (mdc, circular-progress);
   @return (
     // The thickness of the progress spinner's active indicator.
     active-indicator-width: 4px,
-    // The the diameter of the spinner
+    // The diameter of the spinner
     size: 48px,
     // =============================================================================================
     // = TOKENS NOT USED IN ANGULAR MATERIAL                                                       =

package/core/tokens/m2/mdc/_plain-tooltip.scss

@@ -51,9 +51,9 @@ $prefix: (mdc, plain-tooltip);
     // Font for the tooltip text.
     supporting-text-font: typography-utils.font-family($config, caption)
     or typography-utils.font-family($config),
-    // Font size for the the tooltip text.
+    // Font size for the tooltip text.
     supporting-text-size: typography-utils.font-size($config, caption),
-    // Font weight of the the tooltip text.
+    // Font weight of the tooltip text.
     supporting-text-weight: typography-utils.font-weight($config, caption),
     // Tracking (space between letters) of the tooltip text.
     supporting-text-tracking: typography-utils.letter-spacing($config, caption),

package/esm2022/button/button-base.mjs

@@ -6,10 +6,11 @@
  * found in the LICENSE file at https://angular.io/license
  */
 import { FocusMonitor } from '@angular/cdk/a11y';
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
 import { Platform } from '@angular/cdk/platform';
 import { Directive, ElementRef, inject, NgZone, } from '@angular/core';
 import { mixinColor, mixinDisabled, mixinDisableRipple, } from '@angular/material/core';
-import { MAT_BUTTON_RIPPLE_UNINITIALIZED, MatButtonLazyLoader } from './button-lazy-loader';
+import { MatButtonLazyLoader } from './button-lazy-loader';
 import * as i0 from "@angular/core";
 import * as i1 from "@angular/cdk/platform";
 /** Inputs common to all buttons. */
@@ -25,7 +26,6 @@ export const MAT_BUTTON_HOST = {
     // Add a class that applies to all buttons. This makes it easier to target if somebody
     // wants to target all Material buttons.
     '[class.mat-mdc-button-base]': 'true',
-    [MAT_BUTTON_RIPPLE_UNINITIALIZED]: '',
 };
 /** List of classes to add to buttons instances based on host attribute selector. */
 const HOST_SELECTOR_MDC_CLASS_PAIR = [
@@ -73,13 +73,27 @@ export class MatButtonBase extends _MatButtonMixin {
      * @breaking-change 17.0.0
      */
     get ripple() {
-        if (!this._ripple && this._rippleLoader) {
-            this._ripple = this._rippleLoader._createMatRipple(this._elementRef.nativeElement);
-        }
-        return this._ripple;
+        return this._rippleLoader?.getRipple(this._elementRef.nativeElement);
     }
     set ripple(v) {
-        this._ripple = v;
+        this._rippleLoader?.attachRipple(this._elementRef.nativeElement, v);
+    }
+    // We override `disableRipple` and `disabled` so we can hook into
+    // their setters and update the ripple disabled state accordingly.
+    /** Whether the ripple effect is disabled or not. */
+    get disableRipple() {
+        return this._disableRipple;
+    }
+    set disableRipple(value) {
+        this._disableRipple = coerceBooleanProperty(value);
+        this._updateRippleDisabled();
+    }
+    get disabled() {
+        return this._disabled;
+    }
+    set disabled(value) {
+        this._disabled = coerceBooleanProperty(value);
+        this._updateRippleDisabled();
     }
     constructor(elementRef, _platform, _ngZone, _animationMode) {
         super(elementRef);
@@ -94,6 +108,11 @@ export class MatButtonBase extends _MatButtonMixin {
         this._rippleLoader = inject(MatButtonLazyLoader);
         /** Whether this button is a FAB. Used to apply the correct class on the ripple. */
         this._isFab = false;
+        this._disableRipple = false;
+        this._disabled = false;
+        this._rippleLoader?.configureRipple(this._elementRef.nativeElement, {
+            className: 'mat-mdc-button-ripple',
+        });
         const classList = elementRef.nativeElement.classList;
         // For each of the variant selectors that is present in the button's host
         // attributes, add the correct corresponding MDC classes.
@@ -108,11 +127,6 @@ export class MatButtonBase extends _MatButtonMixin {
     ngAfterViewInit() {
         this._focusMonitor.monitor(this._elementRef, true);
     }
-    ngOnChanges() {
-        if (this._ripple) {
-            this._ripple.disabled = this.disableRipple || this.disabled;
-        }
-    }
     ngOnDestroy() {
         this._focusMonitor.stopMonitoring(this._elementRef);
     }
@@ -129,8 +143,11 @@ export class MatButtonBase extends _MatButtonMixin {
     _hasHostAttributes(...attributes) {
         return attributes.some(attribute => this._elementRef.nativeElement.hasAttribute(attribute));
     }
+    _updateRippleDisabled() {
+        this._rippleLoader?.setDisabled(this._elementRef.nativeElement, this.disableRipple || this.disabled);
+    }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.1", ngImport: i0, type: MatButtonBase, deps: "invalid", target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.1.1", type: MatButtonBase, usesInheritance: true, usesOnChanges: true, ngImport: i0 }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.1.1", type: MatButtonBase, usesInheritance: true, ngImport: i0 }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.1", ngImport: i0, type: MatButtonBase, decorators: [{
             type: Directive
@@ -153,7 +170,6 @@ export const MAT_ANCHOR_HOST = {
     // Add a class that applies to all buttons. This makes it easier to target if somebody
     // wants to target all Material buttons.
     '[class.mat-mdc-button-base]': 'true',
-    [MAT_BUTTON_RIPPLE_UNINITIALIZED]: '',
 };
 /**
  * Anchor button base.
@@ -184,4 +200,4 @@ export class MatAnchorBase extends MatButtonBase {
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.1", ngImport: i0, type: MatAnchorBase, decorators: [{
             type: Directive
         }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.Platform }, { type: i0.NgZone }, { type: undefined }]; } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"button-base.js","sourceRoot":"","sources":["../../../../../../src/material/button/button-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 {FocusMonitor, FocusOrigin} from '@angular/cdk/a11y';\nimport {Platform} from '@angular/cdk/platform';\nimport {\n  AfterViewInit,\n  Directive,\n  ElementRef,\n  inject,\n  NgZone,\n  OnChanges,\n  OnDestroy,\n  OnInit,\n} from '@angular/core';\nimport {\n  CanColor,\n  CanDisable,\n  CanDisableRipple,\n  MatRipple,\n  mixinColor,\n  mixinDisabled,\n  mixinDisableRipple,\n} from '@angular/material/core';\nimport {MAT_BUTTON_RIPPLE_UNINITIALIZED, MatButtonLazyLoader} from './button-lazy-loader';\n\n/** Inputs common to all buttons. */\nexport const MAT_BUTTON_INPUTS = ['disabled', 'disableRipple', 'color'];\n\n/** Shared host configuration for all buttons */\nexport const MAT_BUTTON_HOST = {\n  '[attr.disabled]': 'disabled || null',\n  '[class._mat-animation-noopable]': '_animationMode === \"NoopAnimations\"',\n  // MDC automatically applies the primary theme color to the button, but we want to support\n  // an unthemed version. If color is undefined, apply a CSS class that makes it easy to\n  // select and style this \"theme\".\n  '[class.mat-unthemed]': '!color',\n  // Add a class that applies to all buttons. This makes it easier to target if somebody\n  // wants to target all Material buttons.\n  '[class.mat-mdc-button-base]': 'true',\n  [MAT_BUTTON_RIPPLE_UNINITIALIZED]: '',\n};\n\n/** List of classes to add to buttons instances based on host attribute selector. */\nconst HOST_SELECTOR_MDC_CLASS_PAIR: {selector: string; mdcClasses: string[]}[] = [\n  {\n    selector: 'mat-button',\n    mdcClasses: ['mdc-button', 'mat-mdc-button'],\n  },\n  {\n    selector: 'mat-flat-button',\n    mdcClasses: ['mdc-button', 'mdc-button--unelevated', 'mat-mdc-unelevated-button'],\n  },\n  {\n    selector: 'mat-raised-button',\n    mdcClasses: ['mdc-button', 'mdc-button--raised', 'mat-mdc-raised-button'],\n  },\n  {\n    selector: 'mat-stroked-button',\n    mdcClasses: ['mdc-button', 'mdc-button--outlined', 'mat-mdc-outlined-button'],\n  },\n  {\n    selector: 'mat-fab',\n    mdcClasses: ['mdc-fab', 'mat-mdc-fab'],\n  },\n  {\n    selector: 'mat-mini-fab',\n    mdcClasses: ['mdc-fab', 'mdc-fab--mini', 'mat-mdc-mini-fab'],\n  },\n  {\n    selector: 'mat-icon-button',\n    mdcClasses: ['mdc-icon-button', 'mat-mdc-icon-button'],\n  },\n];\n\n// Boilerplate for applying mixins to MatButton.\n/** @docs-private */\nexport const _MatButtonMixin = mixinColor(\n  mixinDisabled(\n    mixinDisableRipple(\n      class {\n        constructor(public _elementRef: ElementRef) {}\n      },\n    ),\n  ),\n);\n\n/** Base class for all buttons.  */\n@Directive()\nexport class MatButtonBase\n  extends _MatButtonMixin\n  implements CanDisable, CanColor, CanDisableRipple, AfterViewInit, OnChanges, OnDestroy\n{\n  private readonly _focusMonitor = inject(FocusMonitor);\n\n  /**\n   * Handles the lazy creation of the MatButton ripple.\n   * Used to improve initial load time of large applications.\n   */\n  _rippleLoader: MatButtonLazyLoader = inject(MatButtonLazyLoader);\n\n  /** Whether this button is a FAB. Used to apply the correct class on the ripple. */\n  _isFab = false;\n\n  /**\n   * Reference to the MatRipple instance of the button.\n   * @deprecated Considered an implementation detail. To be removed.\n   * @breaking-change 17.0.0\n   */\n  get ripple(): MatRipple {\n    if (!this._ripple && this._rippleLoader) {\n      this._ripple = this._rippleLoader._createMatRipple(this._elementRef.nativeElement);\n    }\n    return this._ripple!;\n  }\n  set ripple(v: MatRipple) {\n    this._ripple = v;\n  }\n\n  /** @docs-private Reference to the MatRipple instance of the button. */\n  protected _ripple?: MatRipple;\n\n  constructor(\n    elementRef: ElementRef,\n    public _platform: Platform,\n    public _ngZone: NgZone,\n    public _animationMode?: string,\n  ) {\n    super(elementRef);\n\n    const classList = (elementRef.nativeElement as HTMLElement).classList;\n\n    // For each of the variant selectors that is present in the button's host\n    // attributes, add the correct corresponding MDC classes.\n    for (const pair of HOST_SELECTOR_MDC_CLASS_PAIR) {\n      if (this._hasHostAttributes(pair.selector)) {\n        pair.mdcClasses.forEach((className: string) => {\n          classList.add(className);\n        });\n      }\n    }\n  }\n\n  ngAfterViewInit() {\n    this._focusMonitor.monitor(this._elementRef, true);\n  }\n\n  ngOnChanges() {\n    if (this._ripple) {\n      this._ripple.disabled = this.disableRipple || this.disabled;\n    }\n  }\n\n  ngOnDestroy() {\n    this._focusMonitor.stopMonitoring(this._elementRef);\n  }\n\n  /** Focuses the button. */\n  focus(_origin: FocusOrigin = 'program', options?: FocusOptions): void {\n    if (_origin) {\n      this._focusMonitor.focusVia(this._elementRef.nativeElement, _origin, options);\n    } else {\n      this._elementRef.nativeElement.focus(options);\n    }\n  }\n\n  /** Gets whether the button has one of the given attributes. */\n  private _hasHostAttributes(...attributes: string[]) {\n    return attributes.some(attribute => this._elementRef.nativeElement.hasAttribute(attribute));\n  }\n}\n\n/** Shared inputs by buttons using the `<a>` tag */\nexport const MAT_ANCHOR_INPUTS = ['disabled', 'disableRipple', 'color', 'tabIndex'];\n\n/** Shared host configuration for buttons using the `<a>` tag. */\nexport const MAT_ANCHOR_HOST = {\n  '[attr.disabled]': 'disabled || null',\n  '[class._mat-animation-noopable]': '_animationMode === \"NoopAnimations\"',\n\n  // Note that we ignore the user-specified tabindex when it's disabled for\n  // consistency with the `mat-button` applied on native buttons where even\n  // though they have an index, they're not tabbable.\n  '[attr.tabindex]': 'disabled ? -1 : tabIndex',\n  '[attr.aria-disabled]': 'disabled.toString()',\n  // MDC automatically applies the primary theme color to the button, but we want to support\n  // an unthemed version. If color is undefined, apply a CSS class that makes it easy to\n  // select and style this \"theme\".\n  '[class.mat-unthemed]': '!color',\n  // Add a class that applies to all buttons. This makes it easier to target if somebody\n  // wants to target all Material buttons.\n  '[class.mat-mdc-button-base]': 'true',\n  [MAT_BUTTON_RIPPLE_UNINITIALIZED]: '',\n};\n\n/**\n * Anchor button base.\n */\n@Directive()\nexport class MatAnchorBase extends MatButtonBase implements OnInit, OnDestroy {\n  tabIndex: number;\n\n  constructor(elementRef: ElementRef, platform: Platform, ngZone: NgZone, animationMode?: string) {\n    super(elementRef, platform, ngZone, animationMode);\n  }\n\n  ngOnInit(): void {\n    this._ngZone.runOutsideAngular(() => {\n      this._elementRef.nativeElement.addEventListener('click', this._haltDisabledEvents);\n    });\n  }\n\n  override ngOnDestroy(): void {\n    super.ngOnDestroy();\n    this._elementRef.nativeElement.removeEventListener('click', this._haltDisabledEvents);\n  }\n\n  _haltDisabledEvents = (event: Event): void => {\n    // A disabled button shouldn't apply any actions\n    if (this.disabled) {\n      event.preventDefault();\n      event.stopImmediatePropagation();\n    }\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"button-base.js","sourceRoot":"","sources":["../../../../../../src/material/button/button-base.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAC,YAAY,EAAc,MAAM,mBAAmB,CAAC;AAC5D,OAAO,EAAC,qBAAqB,EAAC,MAAM,uBAAuB,CAAC;AAC5D,OAAO,EAAC,QAAQ,EAAC,MAAM,uBAAuB,CAAC;AAC/C,OAAO,EAEL,SAAS,EACT,UAAU,EACV,MAAM,EACN,MAAM,GAGP,MAAM,eAAe,CAAC;AACvB,OAAO,EAKL,UAAU,EACV,aAAa,EACb,kBAAkB,GACnB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAC,mBAAmB,EAAC,MAAM,sBAAsB,CAAC;;;AAEzD,oCAAoC;AACpC,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,UAAU,EAAE,eAAe,EAAE,OAAO,CAAC,CAAC;AAExE,gDAAgD;AAChD,MAAM,CAAC,MAAM,eAAe,GAAG;IAC7B,iBAAiB,EAAE,kBAAkB;IACrC,iCAAiC,EAAE,qCAAqC;IACxE,0FAA0F;IAC1F,sFAAsF;IACtF,iCAAiC;IACjC,sBAAsB,EAAE,QAAQ;IAChC,sFAAsF;IACtF,wCAAwC;IACxC,6BAA6B,EAAE,MAAM;CACtC,CAAC;AAEF,oFAAoF;AACpF,MAAM,4BAA4B,GAA+C;IAC/E;QACE,QAAQ,EAAE,YAAY;QACtB,UAAU,EAAE,CAAC,YAAY,EAAE,gBAAgB,CAAC;KAC7C;IACD;QACE,QAAQ,EAAE,iBAAiB;QAC3B,UAAU,EAAE,CAAC,YAAY,EAAE,wBAAwB,EAAE,2BAA2B,CAAC;KAClF;IACD;QACE,QAAQ,EAAE,mBAAmB;QAC7B,UAAU,EAAE,CAAC,YAAY,EAAE,oBAAoB,EAAE,uBAAuB,CAAC;KAC1E;IACD;QACE,QAAQ,EAAE,oBAAoB;QAC9B,UAAU,EAAE,CAAC,YAAY,EAAE,sBAAsB,EAAE,yBAAyB,CAAC;KAC9E;IACD;QACE,QAAQ,EAAE,SAAS;QACnB,UAAU,EAAE,CAAC,SAAS,EAAE,aAAa,CAAC;KACvC;IACD;QACE,QAAQ,EAAE,cAAc;QACxB,UAAU,EAAE,CAAC,SAAS,EAAE,eAAe,EAAE,kBAAkB,CAAC;KAC7D;IACD;QACE,QAAQ,EAAE,iBAAiB;QAC3B,UAAU,EAAE,CAAC,iBAAiB,EAAE,qBAAqB,CAAC;KACvD;CACF,CAAC;AAEF,gDAAgD;AAChD,oBAAoB;AACpB,MAAM,CAAC,MAAM,eAAe,GAAG,UAAU,CACvC,aAAa,CACX,kBAAkB,CAChB;IACE,YAAmB,WAAuB;QAAvB,gBAAW,GAAX,WAAW,CAAY;IAAG,CAAC;CAC/C,CACF,CACF,CACF,CAAC;AAEF,mCAAmC;AAEnC,MAAM,OAAO,aACX,SAAQ,eAAe;IAcvB;;;;OAIG;IACH,IAAI,MAAM;QACR,OAAO,IAAI,CAAC,aAAa,EAAE,SAAS,CAAC,IAAI,CAAC,WAAW,CAAC,aAAa,CAAE,CAAC;IACxE,CAAC;IACD,IAAI,MAAM,CAAC,CAAY;QACrB,IAAI,CAAC,aAAa,EAAE,YAAY,CAAC,IAAI,CAAC,WAAW,CAAC,aAAa,EAAE,CAAC,CAAC,CAAC;IACtE,CAAC;IAED,iEAAiE;IACjE,kEAAkE;IAElE,oDAAoD;IACpD,IAAa,aAAa;QACxB,OAAO,IAAI,CAAC,cAAc,CAAC;IAC7B,CAAC;IACD,IAAa,aAAa,CAAC,KAAU;QACnC,IAAI,CAAC,cAAc,GAAG,qBAAqB,CAAC,KAAK,CAAC,CAAC;QACnD,IAAI,CAAC,qBAAqB,EAAE,CAAC;IAC/B,CAAC;IAGD,IAAa,QAAQ;QACnB,OAAO,IAAI,CAAC,SAAS,CAAC;IACxB,CAAC;IACD,IAAa,QAAQ,CAAC,KAAU;QAC9B,IAAI,CAAC,SAAS,GAAG,qBAAqB,CAAC,KAAK,CAAC,CAAC;QAC9C,IAAI,CAAC,qBAAqB,EAAE,CAAC;IAC/B,CAAC;IAGD,YACE,UAAsB,EACf,SAAmB,EACnB,OAAe,EACf,cAAuB;QAE9B,KAAK,CAAC,UAAU,CAAC,CAAC;QAJX,cAAS,GAAT,SAAS,CAAU;QACnB,YAAO,GAAP,OAAO,CAAQ;QACf,mBAAc,GAAd,cAAc,CAAS;QAjDf,kBAAa,GAAG,MAAM,CAAC,YAAY,CAAC,CAAC;QAEtD;;;WAGG;QACH,kBAAa,GAAwB,MAAM,CAAC,mBAAmB,CAAC,CAAC;QAEjE,mFAAmF;QACnF,WAAM,GAAG,KAAK,CAAC;QAyBP,mBAAc,GAAY,KAAK,CAAC;QAShC,cAAS,GAAY,KAAK,CAAC;QAUjC,IAAI,CAAC,aAAa,EAAE,eAAe,CAAC,IAAI,CAAC,WAAW,CAAC,aAAa,EAAE;YAClE,SAAS,EAAE,uBAAuB;SACnC,CAAC,CAAC;QAEH,MAAM,SAAS,GAAI,UAAU,CAAC,aAA6B,CAAC,SAAS,CAAC;QAEtE,yEAAyE;QACzE,yDAAyD;QACzD,KAAK,MAAM,IAAI,IAAI,4BAA4B,EAAE;YAC/C,IAAI,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE;gBAC1C,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,SAAiB,EAAE,EAAE;oBAC5C,SAAS,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;gBAC3B,CAAC,CAAC,CAAC;aACJ;SACF;IACH,CAAC;IAED,eAAe;QACb,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,IAAI,CAAC,WAAW,EAAE,IAAI,CAAC,CAAC;IACrD,CAAC;IAED,WAAW;QACT,IAAI,CAAC,aAAa,CAAC,cAAc,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;IACtD,CAAC;IAED,0BAA0B;IAC1B,KAAK,CAAC,UAAuB,SAAS,EAAE,OAAsB;QAC5D,IAAI,OAAO,EAAE;YACX,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC,aAAa,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;SAC/E;aAAM;YACL,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;SAC/C;IACH,CAAC;IAED,+DAA+D;IACvD,kBAAkB,CAAC,GAAG,UAAoB;QAChD,OAAO,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC,CAAC;IAC9F,CAAC;IAEO,qBAAqB;QAC3B,IAAI,CAAC,aAAa,EAAE,WAAW,CAC7B,IAAI,CAAC,WAAW,CAAC,aAAa,EAC9B,IAAI,CAAC,aAAa,IAAI,IAAI,CAAC,QAAQ,CACpC,CAAC;IACJ,CAAC;8GArGU,aAAa;kGAAb,aAAa;;2FAAb,aAAa;kBADzB,SAAS;;AAyGV,mDAAmD;AACnD,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,UAAU,EAAE,eAAe,EAAE,OAAO,EAAE,UAAU,CAAC,CAAC;AAEpF,iEAAiE;AACjE,MAAM,CAAC,MAAM,eAAe,GAAG;IAC7B,iBAAiB,EAAE,kBAAkB;IACrC,iCAAiC,EAAE,qCAAqC;IAExE,yEAAyE;IACzE,yEAAyE;IACzE,mDAAmD;IACnD,iBAAiB,EAAE,0BAA0B;IAC7C,sBAAsB,EAAE,qBAAqB;IAC7C,0FAA0F;IAC1F,sFAAsF;IACtF,iCAAiC;IACjC,sBAAsB,EAAE,QAAQ;IAChC,sFAAsF;IACtF,wCAAwC;IACxC,6BAA6B,EAAE,MAAM;CACtC,CAAC;AAEF;;GAEG;AAEH,MAAM,OAAO,aAAc,SAAQ,aAAa;IAG9C,YAAY,UAAsB,EAAE,QAAkB,EAAE,MAAc,EAAE,aAAsB;QAC5F,KAAK,CAAC,UAAU,EAAE,QAAQ,EAAE,MAAM,EAAE,aAAa,CAAC,CAAC;QAcrD,wBAAmB,GAAG,CAAC,KAAY,EAAQ,EAAE;YAC3C,gDAAgD;YAChD,IAAI,IAAI,CAAC,QAAQ,EAAE;gBACjB,KAAK,CAAC,cAAc,EAAE,CAAC;gBACvB,KAAK,CAAC,wBAAwB,EAAE,CAAC;aAClC;QACH,CAAC,CAAC;IAnBF,CAAC;IAED,QAAQ;QACN,IAAI,CAAC,OAAO,CAAC,iBAAiB,CAAC,GAAG,EAAE;YAClC,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,gBAAgB,CAAC,OAAO,EAAE,IAAI,CAAC,mBAAmB,CAAC,CAAC;QACrF,CAAC,CAAC,CAAC;IACL,CAAC;IAEQ,WAAW;QAClB,KAAK,CAAC,WAAW,EAAE,CAAC;QACpB,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,mBAAmB,CAAC,OAAO,EAAE,IAAI,CAAC,mBAAmB,CAAC,CAAC;IACxF,CAAC;8GAhBU,aAAa;kGAAb,aAAa;;2FAAb,aAAa;kBADzB,SAAS","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 {FocusMonitor, FocusOrigin} from '@angular/cdk/a11y';\nimport {coerceBooleanProperty} from '@angular/cdk/coercion';\nimport {Platform} from '@angular/cdk/platform';\nimport {\n  AfterViewInit,\n  Directive,\n  ElementRef,\n  inject,\n  NgZone,\n  OnDestroy,\n  OnInit,\n} from '@angular/core';\nimport {\n  CanColor,\n  CanDisable,\n  CanDisableRipple,\n  MatRipple,\n  mixinColor,\n  mixinDisabled,\n  mixinDisableRipple,\n} from '@angular/material/core';\nimport {MatButtonLazyLoader} from './button-lazy-loader';\n\n/** Inputs common to all buttons. */\nexport const MAT_BUTTON_INPUTS = ['disabled', 'disableRipple', 'color'];\n\n/** Shared host configuration for all buttons */\nexport const MAT_BUTTON_HOST = {\n  '[attr.disabled]': 'disabled || null',\n  '[class._mat-animation-noopable]': '_animationMode === \"NoopAnimations\"',\n  // MDC automatically applies the primary theme color to the button, but we want to support\n  // an unthemed version. If color is undefined, apply a CSS class that makes it easy to\n  // select and style this \"theme\".\n  '[class.mat-unthemed]': '!color',\n  // Add a class that applies to all buttons. This makes it easier to target if somebody\n  // wants to target all Material buttons.\n  '[class.mat-mdc-button-base]': 'true',\n};\n\n/** List of classes to add to buttons instances based on host attribute selector. */\nconst HOST_SELECTOR_MDC_CLASS_PAIR: {selector: string; mdcClasses: string[]}[] = [\n  {\n    selector: 'mat-button',\n    mdcClasses: ['mdc-button', 'mat-mdc-button'],\n  },\n  {\n    selector: 'mat-flat-button',\n    mdcClasses: ['mdc-button', 'mdc-button--unelevated', 'mat-mdc-unelevated-button'],\n  },\n  {\n    selector: 'mat-raised-button',\n    mdcClasses: ['mdc-button', 'mdc-button--raised', 'mat-mdc-raised-button'],\n  },\n  {\n    selector: 'mat-stroked-button',\n    mdcClasses: ['mdc-button', 'mdc-button--outlined', 'mat-mdc-outlined-button'],\n  },\n  {\n    selector: 'mat-fab',\n    mdcClasses: ['mdc-fab', 'mat-mdc-fab'],\n  },\n  {\n    selector: 'mat-mini-fab',\n    mdcClasses: ['mdc-fab', 'mdc-fab--mini', 'mat-mdc-mini-fab'],\n  },\n  {\n    selector: 'mat-icon-button',\n    mdcClasses: ['mdc-icon-button', 'mat-mdc-icon-button'],\n  },\n];\n\n// Boilerplate for applying mixins to MatButton.\n/** @docs-private */\nexport const _MatButtonMixin = mixinColor(\n  mixinDisabled(\n    mixinDisableRipple(\n      class {\n        constructor(public _elementRef: ElementRef) {}\n      },\n    ),\n  ),\n);\n\n/** Base class for all buttons.  */\n@Directive()\nexport class MatButtonBase\n  extends _MatButtonMixin\n  implements CanDisable, CanColor, CanDisableRipple, AfterViewInit, OnDestroy\n{\n  private readonly _focusMonitor = inject(FocusMonitor);\n\n  /**\n   * Handles the lazy creation of the MatButton ripple.\n   * Used to improve initial load time of large applications.\n   */\n  _rippleLoader: MatButtonLazyLoader = inject(MatButtonLazyLoader);\n\n  /** Whether this button is a FAB. Used to apply the correct class on the ripple. */\n  _isFab = false;\n\n  /**\n   * Reference to the MatRipple instance of the button.\n   * @deprecated Considered an implementation detail. To be removed.\n   * @breaking-change 17.0.0\n   */\n  get ripple(): MatRipple {\n    return this._rippleLoader?.getRipple(this._elementRef.nativeElement)!;\n  }\n  set ripple(v: MatRipple) {\n    this._rippleLoader?.attachRipple(this._elementRef.nativeElement, v);\n  }\n\n  // We override `disableRipple` and `disabled` so we can hook into\n  // their setters and update the ripple disabled state accordingly.\n\n  /** Whether the ripple effect is disabled or not. */\n  override get disableRipple(): boolean {\n    return this._disableRipple;\n  }\n  override set disableRipple(value: any) {\n    this._disableRipple = coerceBooleanProperty(value);\n    this._updateRippleDisabled();\n  }\n  private _disableRipple: boolean = false;\n\n  override get disabled(): boolean {\n    return this._disabled;\n  }\n  override set disabled(value: any) {\n    this._disabled = coerceBooleanProperty(value);\n    this._updateRippleDisabled();\n  }\n  private _disabled: boolean = false;\n\n  constructor(\n    elementRef: ElementRef,\n    public _platform: Platform,\n    public _ngZone: NgZone,\n    public _animationMode?: string,\n  ) {\n    super(elementRef);\n\n    this._rippleLoader?.configureRipple(this._elementRef.nativeElement, {\n      className: 'mat-mdc-button-ripple',\n    });\n\n    const classList = (elementRef.nativeElement as HTMLElement).classList;\n\n    // For each of the variant selectors that is present in the button's host\n    // attributes, add the correct corresponding MDC classes.\n    for (const pair of HOST_SELECTOR_MDC_CLASS_PAIR) {\n      if (this._hasHostAttributes(pair.selector)) {\n        pair.mdcClasses.forEach((className: string) => {\n          classList.add(className);\n        });\n      }\n    }\n  }\n\n  ngAfterViewInit() {\n    this._focusMonitor.monitor(this._elementRef, true);\n  }\n\n  ngOnDestroy() {\n    this._focusMonitor.stopMonitoring(this._elementRef);\n  }\n\n  /** Focuses the button. */\n  focus(_origin: FocusOrigin = 'program', options?: FocusOptions): void {\n    if (_origin) {\n      this._focusMonitor.focusVia(this._elementRef.nativeElement, _origin, options);\n    } else {\n      this._elementRef.nativeElement.focus(options);\n    }\n  }\n\n  /** Gets whether the button has one of the given attributes. */\n  private _hasHostAttributes(...attributes: string[]) {\n    return attributes.some(attribute => this._elementRef.nativeElement.hasAttribute(attribute));\n  }\n\n  private _updateRippleDisabled(): void {\n    this._rippleLoader?.setDisabled(\n      this._elementRef.nativeElement,\n      this.disableRipple || this.disabled,\n    );\n  }\n}\n\n/** Shared inputs by buttons using the `<a>` tag */\nexport const MAT_ANCHOR_INPUTS = ['disabled', 'disableRipple', 'color', 'tabIndex'];\n\n/** Shared host configuration for buttons using the `<a>` tag. */\nexport const MAT_ANCHOR_HOST = {\n  '[attr.disabled]': 'disabled || null',\n  '[class._mat-animation-noopable]': '_animationMode === \"NoopAnimations\"',\n\n  // Note that we ignore the user-specified tabindex when it's disabled for\n  // consistency with the `mat-button` applied on native buttons where even\n  // though they have an index, they're not tabbable.\n  '[attr.tabindex]': 'disabled ? -1 : tabIndex',\n  '[attr.aria-disabled]': 'disabled.toString()',\n  // MDC automatically applies the primary theme color to the button, but we want to support\n  // an unthemed version. If color is undefined, apply a CSS class that makes it easy to\n  // select and style this \"theme\".\n  '[class.mat-unthemed]': '!color',\n  // Add a class that applies to all buttons. This makes it easier to target if somebody\n  // wants to target all Material buttons.\n  '[class.mat-mdc-button-base]': 'true',\n};\n\n/**\n * Anchor button base.\n */\n@Directive()\nexport class MatAnchorBase extends MatButtonBase implements OnInit, OnDestroy {\n  tabIndex: number;\n\n  constructor(elementRef: ElementRef, platform: Platform, ngZone: NgZone, animationMode?: string) {\n    super(elementRef, platform, ngZone, animationMode);\n  }\n\n  ngOnInit(): void {\n    this._ngZone.runOutsideAngular(() => {\n      this._elementRef.nativeElement.addEventListener('click', this._haltDisabledEvents);\n    });\n  }\n\n  override ngOnDestroy(): void {\n    super.ngOnDestroy();\n    this._elementRef.nativeElement.removeEventListener('click', this._haltDisabledEvents);\n  }\n\n  _haltDisabledEvents = (event: Event): void => {\n    // A disabled button shouldn't apply any actions\n    if (this.disabled) {\n      event.preventDefault();\n      event.stopImmediatePropagation();\n    }\n  };\n}\n"]}

package/esm2022/button/button-lazy-loader.mjs

@@ -7,20 +7,26 @@
  */
 import { DOCUMENT } from '@angular/common';
 import { ANIMATION_MODULE_TYPE, ElementRef, Injectable, NgZone, inject, } from '@angular/core';
-import { MAT_RIPPLE_GLOBAL_OPTIONS, MatRipple, RippleRenderer, } from '@angular/material/core';
 import { Platform } from '@angular/cdk/platform';
+import { MAT_RIPPLE_GLOBAL_OPTIONS, MatRipple } from '@angular/material/core';
 import * as i0 from "@angular/core";
 /** The options for the MatButtonRippleLoader's event listeners. */
 const eventListenerOptions = { capture: true };
 /** The events that should trigger the initialization of the ripple. */
 const rippleInteractionEvents = ['focus', 'click', 'mouseenter', 'touchstart'];
-/** The attribute attached to a mat-button whose ripple has not yet been initialized. */
-export const MAT_BUTTON_RIPPLE_UNINITIALIZED = 'mat-button-ripple-uninitialized';
+/** The attribute attached to a component whose ripple has not yet been initialized. */
+const matRippleUninitialized = 'mat-ripple-loader-uninitialized';
+/** Additional classes that should be added to the ripple when it is rendered. */
+const matRippleClassName = 'mat-ripple-loader-class-name';
+/** Whether the ripple should be centered. */
+const matRippleCentered = 'mat-ripple-loader-centered';
+/** Whether the ripple should be disabled. */
+const matRippleDisabled = 'mat-ripple-loader-disabled';
 /**
- * Handles attaching the MatButton's ripple on demand.
+ * Handles attaching ripples on demand.
  *
- * This service allows us to avoid eagerly creating & attaching the MatButton's ripple.
- * It works by creating & attaching the ripple only when a MatButton is first interacted with.
+ * This service allows us to avoid eagerly creating & attaching MatRipples.
+ * It works by creating & attaching a ripple only when a component is first interacted with.
  */
 export class MatButtonLazyLoader {
     constructor() {
@@ -29,17 +35,16 @@ export class MatButtonLazyLoader {
         this._globalRippleOptions = inject(MAT_RIPPLE_GLOBAL_OPTIONS, { optional: true });
         this._platform = inject(Platform);
         this._ngZone = inject(NgZone);
-        /** Handles creating and attaching button internals when a button is initially interacted with. */
+        /** Handles creating and attaching component internals when a component it is initially interacted with. */
         this._onInteraction = (event) => {
-            if (event.target === this._document) {
+            if (!(event.target instanceof HTMLElement)) {
                 return;
             }
             const eventTarget = event.target;
             // TODO(wagnermaciel): Consider batching these events to improve runtime performance.
-            const button = eventTarget.closest(`[${MAT_BUTTON_RIPPLE_UNINITIALIZED}]`);
-            if (button) {
-                button.removeAttribute(MAT_BUTTON_RIPPLE_UNINITIALIZED);
-                this._appendRipple(button);
+            const element = eventTarget.closest(`[${matRippleUninitialized}]`);
+            if (element) {
+                this.createRipple(element);
             }
         };
         this._ngZone.runOutsideAngular(() => {
@@ -53,33 +58,74 @@ export class MatButtonLazyLoader {
             this._document?.removeEventListener(event, this._onInteraction, eventListenerOptions);
         }
     }
-    /** Creates a MatButtonRipple and appends it to the given button element. */
-    _appendRipple(button) {
-        if (!this._document) {
+    /**
+     * Configures the ripple that will be rendered by the ripple loader.
+     *
+     * Stores the given information about how the ripple should be configured on the host
+     * element so that it can later be retrived & used when the ripple is actually created.
+     */
+    configureRipple(host, config) {
+        // Indicates that the ripple has not yet been rendered for this component.
+        host.setAttribute(matRippleUninitialized, '');
+        // Store the additional class name(s) that should be added to the ripple element.
+        if (config.className || !host.hasAttribute(matRippleClassName)) {
+            host.setAttribute(matRippleClassName, config.className || '');
+        }
+        // Store whether the ripple should be centered.
+        if (config.centered) {
+            host.setAttribute(matRippleCentered, '');
+        }
+        if (config.disabled) {
+            host.setAttribute(matRippleDisabled, '');
+        }
+    }
+    /** Returns the ripple instance for the given host element. */
+    getRipple(host) {
+        if (host.matRipple) {
+            return host.matRipple;
+        }
+        return this.createRipple(host);
+    }
+    /** Sets the disabled state on the ripple instance corresponding to the given host element. */
+    setDisabled(host, disabled) {
+        const ripple = host.matRipple;
+        // If the ripple has already been instantiated, just disable it.
+        if (ripple) {
+            ripple.disabled = disabled;
             return;
         }
-        const ripple = this._document.createElement('span');
-        ripple.classList.add('mat-mdc-button-ripple');
-        const target = new MatButtonRippleTarget(button, this._globalRippleOptions ? this._globalRippleOptions : undefined, this._animationMode ? this._animationMode : undefined);
-        target.rippleConfig.centered = button.hasAttribute('mat-icon-button');
-        const rippleRenderer = new RippleRenderer(target, this._ngZone, ripple, this._platform);
-        rippleRenderer.setupTriggerEvents(button);
-        button.append(ripple);
+        // Otherwise, set an attribute so we know what the
+        // disabled state should be when the ripple is initialized.
+        if (disabled) {
+            host.setAttribute(matRippleDisabled, '');
+        }
+        else {
+            host.removeAttribute(matRippleDisabled);
+        }
     }
-    _createMatRipple(button) {
+    /** Creates a MatRipple and appends it to the given element. */
+    createRipple(host) {
         if (!this._document) {
             return;
         }
-        button.querySelector('.mat-mdc-button-ripple')?.remove();
-        button.removeAttribute(MAT_BUTTON_RIPPLE_UNINITIALIZED);
+        // Create the ripple element.
+        host.querySelector('.mat-ripple')?.remove();
         const rippleEl = this._document.createElement('span');
-        rippleEl.classList.add('mat-mdc-button-ripple');
+        rippleEl.classList.add('mat-ripple', host.getAttribute(matRippleClassName));
+        host.append(rippleEl);
+        // Create the MatRipple.
         const ripple = new MatRipple(new ElementRef(rippleEl), this._ngZone, this._platform, this._globalRippleOptions ? this._globalRippleOptions : undefined, this._animationMode ? this._animationMode : undefined);
         ripple._isInitialized = true;
-        ripple.trigger = button;
-        button.append(rippleEl);
+        ripple.trigger = host;
+        ripple.centered = host.hasAttribute(matRippleCentered);
+        ripple.disabled = host.hasAttribute(matRippleDisabled);
+        this.attachRipple(host, ripple);
         return ripple;
     }
+    attachRipple(host, ripple) {
+        host.removeAttribute(matRippleUninitialized);
+        host.matRipple = ripple;
+    }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.1", ngImport: i0, type: MatButtonLazyLoader, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.1.1", ngImport: i0, type: MatButtonLazyLoader, providedIn: 'root' }); }
 }
@@ -87,27 +133,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.1", ngImpor
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }], ctorParameters: function () { return []; } });
-/**
- * The RippleTarget for the lazily rendered MatButton ripple.
- * It handles ripple configuration and disabled state for ripples interactions.
- *
- * Note that this configuration is usually handled by the MatRipple, but the MatButtonLazyLoader does not use the
- * MatRipple Directive. In order to create & attach a ripple on demand, it uses the "lower level" RippleRenderer.
- */
-class MatButtonRippleTarget {
-    constructor(_button, _globalRippleOptions, animationMode) {
-        this._button = _button;
-        this._globalRippleOptions = _globalRippleOptions;
-        this._setRippleConfig(_globalRippleOptions, animationMode);
-    }
-    _setRippleConfig(globalRippleOptions, animationMode) {
-        this.rippleConfig = globalRippleOptions || {};
-        if (animationMode === 'NoopAnimations') {
-            this.rippleConfig.animation = { enterDuration: 0, exitDuration: 0 };
-        }
-    }
-    get rippleDisabled() {
-        return this._button.hasAttribute('disabled') || !!this._globalRippleOptions?.disabled;
-    }
-}
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"button-lazy-loader.js","sourceRoot":"","sources":["../../../../../../src/material/button/button-lazy-loader.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAC,QAAQ,EAAC,MAAM,iBAAiB,CAAC;AACzC,OAAO,EACL,qBAAqB,EACrB,UAAU,EACV,UAAU,EACV,MAAM,EAEN,MAAM,GACP,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,yBAAyB,EACzB,SAAS,EAGT,cAAc,GAEf,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAC,QAAQ,EAAC,MAAM,uBAAuB,CAAC;;AAE/C,mEAAmE;AACnE,MAAM,oBAAoB,GAAG,EAAC,OAAO,EAAE,IAAI,EAAC,CAAC;AAE7C,uEAAuE;AACvE,MAAM,uBAAuB,GAAG,CAAC,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,YAAY,CAAC,CAAC;AAE/E,wFAAwF;AACxF,MAAM,CAAC,MAAM,+BAA+B,GAAG,iCAAiC,CAAC;AAEjF;;;;;GAKG;AAEH,MAAM,OAAO,mBAAmB;IAO9B;QANQ,cAAS,GAAG,MAAM,CAAC,QAAQ,EAAE,EAAC,QAAQ,EAAE,IAAI,EAAC,CAAC,CAAC;QAC/C,mBAAc,GAAG,MAAM,CAAC,qBAAqB,EAAE,EAAC,QAAQ,EAAE,IAAI,EAAC,CAAC,CAAC;QACjE,yBAAoB,GAAG,MAAM,CAAC,yBAAyB,EAAE,EAAC,QAAQ,EAAE,IAAI,EAAC,CAAC,CAAC;QAC3E,cAAS,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC;QAC7B,YAAO,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC;QAgBjC,kGAAkG;QAC1F,mBAAc,GAAG,CAAC,KAAY,EAAE,EAAE;YACxC,IAAI,KAAK,CAAC,MAAM,KAAK,IAAI,CAAC,SAAS,EAAE;gBACnC,OAAO;aACR;YACD,MAAM,WAAW,GAAG,KAAK,CAAC,MAAiB,CAAC;YAE5C,qFAAqF;YAErF,MAAM,MAAM,GAAG,WAAW,CAAC,OAAO,CAAC,IAAI,+BAA+B,GAAG,CAAC,CAAC;YAC3E,IAAI,MAAM,EAAE;gBACV,MAAM,CAAC,eAAe,CAAC,+BAA+B,CAAC,CAAC;gBACxD,IAAI,CAAC,aAAa,CAAC,MAAqB,CAAC,CAAC;aAC3C;QACH,CAAC,CAAC;QA3BA,IAAI,CAAC,OAAO,CAAC,iBAAiB,CAAC,GAAG,EAAE;YAClC,KAAK,MAAM,KAAK,IAAI,uBAAuB,EAAE;gBAC3C,IAAI,CAAC,SAAS,EAAE,gBAAgB,CAAC,KAAK,EAAE,IAAI,CAAC,cAAc,EAAE,oBAAoB,CAAC,CAAC;aACpF;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IAED,WAAW;QACT,KAAK,MAAM,KAAK,IAAI,uBAAuB,EAAE;YAC3C,IAAI,CAAC,SAAS,EAAE,mBAAmB,CAAC,KAAK,EAAE,IAAI,CAAC,cAAc,EAAE,oBAAoB,CAAC,CAAC;SACvF;IACH,CAAC;IAkBD,4EAA4E;IACpE,aAAa,CAAC,MAAmB;QACvC,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE;YACnB,OAAO;SACR;QACD,MAAM,MAAM,GAAG,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC;QACpD,MAAM,CAAC,SAAS,CAAC,GAAG,CAAC,uBAAuB,CAAC,CAAC;QAE9C,MAAM,MAAM,GAAG,IAAI,qBAAqB,CACtC,MAAM,EACN,IAAI,CAAC,oBAAoB,CAAC,CAAC,CAAC,IAAI,CAAC,oBAAoB,CAAC,CAAC,CAAC,SAAS,EACjE,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC,SAAS,CACtD,CAAC;QACF,MAAM,CAAC,YAAY,CAAC,QAAQ,GAAG,MAAM,CAAC,YAAY,CAAC,iBAAiB,CAAC,CAAC;QAEtE,MAAM,cAAc,GAAG,IAAI,cAAc,CAAC,MAAM,EAAE,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC;QACxF,cAAc,CAAC,kBAAkB,CAAC,MAAM,CAAC,CAAC;QAC1C,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IACxB,CAAC;IAED,gBAAgB,CAAC,MAAmB;QAClC,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE;YACnB,OAAO;SACR;QACD,MAAM,CAAC,aAAa,CAAC,wBAAwB,CAAC,EAAE,MAAM,EAAE,CAAC;QACzD,MAAM,CAAC,eAAe,CAAC,+BAA+B,CAAC,CAAC;QACxD,MAAM,QAAQ,GAAG,IAAI,CAAC,SAAU,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC;QACvD,QAAQ,CAAC,SAAS,CAAC,GAAG,CAAC,uBAAuB,CAAC,CAAC;QAChD,MAAM,MAAM,GAAG,IAAI,SAAS,CAC1B,IAAI,UAAU,CAAC,QAAQ,CAAC,EACxB,IAAI,CAAC,OAAO,EACZ,IAAI,CAAC,SAAS,EACd,IAAI,CAAC,oBAAoB,CAAC,CAAC,CAAC,IAAI,CAAC,oBAAoB,CAAC,CAAC,CAAC,SAAS,EACjE,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC,SAAS,CACtD,CAAC;QACF,MAAM,CAAC,cAAc,GAAG,IAAI,CAAC;QAC7B,MAAM,CAAC,OAAO,GAAG,MAAM,CAAC;QACxB,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QACxB,OAAO,MAAM,CAAC;IAChB,CAAC;8GA5EU,mBAAmB;kHAAnB,mBAAmB,cADP,MAAM;;2FAClB,mBAAmB;kBAD/B,UAAU;mBAAC,EAAC,UAAU,EAAE,MAAM,EAAC;;AAgFhC;;;;;;GAMG;AACH,MAAM,qBAAqB;IAGzB,YACU,OAAoB,EACpB,oBAA0C,EAClD,aAAsB;QAFd,YAAO,GAAP,OAAO,CAAa;QACpB,yBAAoB,GAApB,oBAAoB,CAAsB;QAGlD,IAAI,CAAC,gBAAgB,CAAC,oBAAoB,EAAE,aAAa,CAAC,CAAC;IAC7D,CAAC;IAEO,gBAAgB,CAAC,mBAAyC,EAAE,aAAsB;QACxF,IAAI,CAAC,YAAY,GAAG,mBAAmB,IAAI,EAAE,CAAC;QAC9C,IAAI,aAAa,KAAK,gBAAgB,EAAE;YACtC,IAAI,CAAC,YAAY,CAAC,SAAS,GAAG,EAAC,aAAa,EAAE,CAAC,EAAE,YAAY,EAAE,CAAC,EAAC,CAAC;SACnE;IACH,CAAC;IAED,IAAI,cAAc;QAChB,OAAO,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,oBAAoB,EAAE,QAAQ,CAAC;IACxF,CAAC;CACF","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 {DOCUMENT} from '@angular/common';\nimport {\n  ANIMATION_MODULE_TYPE,\n  ElementRef,\n  Injectable,\n  NgZone,\n  OnDestroy,\n  inject,\n} from '@angular/core';\nimport {\n  MAT_RIPPLE_GLOBAL_OPTIONS,\n  MatRipple,\n  RippleConfig,\n  RippleGlobalOptions,\n  RippleRenderer,\n  RippleTarget,\n} from '@angular/material/core';\nimport {Platform} from '@angular/cdk/platform';\n\n/** The options for the MatButtonRippleLoader's event listeners. */\nconst eventListenerOptions = {capture: true};\n\n/** The events that should trigger the initialization of the ripple. */\nconst rippleInteractionEvents = ['focus', 'click', 'mouseenter', 'touchstart'];\n\n/** The attribute attached to a mat-button whose ripple has not yet been initialized. */\nexport const MAT_BUTTON_RIPPLE_UNINITIALIZED = 'mat-button-ripple-uninitialized';\n\n/**\n * Handles attaching the MatButton's ripple on demand.\n *\n * This service allows us to avoid eagerly creating & attaching the MatButton's ripple.\n * It works by creating & attaching the ripple only when a MatButton is first interacted with.\n */\n@Injectable({providedIn: 'root'})\nexport class MatButtonLazyLoader implements OnDestroy {\n  private _document = inject(DOCUMENT, {optional: true});\n  private _animationMode = inject(ANIMATION_MODULE_TYPE, {optional: true});\n  private _globalRippleOptions = inject(MAT_RIPPLE_GLOBAL_OPTIONS, {optional: true});\n  private _platform = inject(Platform);\n  private _ngZone = inject(NgZone);\n\n  constructor() {\n    this._ngZone.runOutsideAngular(() => {\n      for (const event of rippleInteractionEvents) {\n        this._document?.addEventListener(event, this._onInteraction, eventListenerOptions);\n      }\n    });\n  }\n\n  ngOnDestroy() {\n    for (const event of rippleInteractionEvents) {\n      this._document?.removeEventListener(event, this._onInteraction, eventListenerOptions);\n    }\n  }\n\n  /** Handles creating and attaching button internals when a button is initially interacted with. */\n  private _onInteraction = (event: Event) => {\n    if (event.target === this._document) {\n      return;\n    }\n    const eventTarget = event.target as Element;\n\n    // TODO(wagnermaciel): Consider batching these events to improve runtime performance.\n\n    const button = eventTarget.closest(`[${MAT_BUTTON_RIPPLE_UNINITIALIZED}]`);\n    if (button) {\n      button.removeAttribute(MAT_BUTTON_RIPPLE_UNINITIALIZED);\n      this._appendRipple(button as HTMLElement);\n    }\n  };\n\n  /** Creates a MatButtonRipple and appends it to the given button element. */\n  private _appendRipple(button: HTMLElement): void {\n    if (!this._document) {\n      return;\n    }\n    const ripple = this._document.createElement('span');\n    ripple.classList.add('mat-mdc-button-ripple');\n\n    const target = new MatButtonRippleTarget(\n      button,\n      this._globalRippleOptions ? this._globalRippleOptions : undefined,\n      this._animationMode ? this._animationMode : undefined,\n    );\n    target.rippleConfig.centered = button.hasAttribute('mat-icon-button');\n\n    const rippleRenderer = new RippleRenderer(target, this._ngZone, ripple, this._platform);\n    rippleRenderer.setupTriggerEvents(button);\n    button.append(ripple);\n  }\n\n  _createMatRipple(button: HTMLElement): MatRipple | undefined {\n    if (!this._document) {\n      return;\n    }\n    button.querySelector('.mat-mdc-button-ripple')?.remove();\n    button.removeAttribute(MAT_BUTTON_RIPPLE_UNINITIALIZED);\n    const rippleEl = this._document!.createElement('span');\n    rippleEl.classList.add('mat-mdc-button-ripple');\n    const ripple = new MatRipple(\n      new ElementRef(rippleEl),\n      this._ngZone,\n      this._platform,\n      this._globalRippleOptions ? this._globalRippleOptions : undefined,\n      this._animationMode ? this._animationMode : undefined,\n    );\n    ripple._isInitialized = true;\n    ripple.trigger = button;\n    button.append(rippleEl);\n    return ripple;\n  }\n}\n\n/**\n * The RippleTarget for the lazily rendered MatButton ripple.\n * It handles ripple configuration and disabled state for ripples interactions.\n *\n * Note that this configuration is usually handled by the MatRipple, but the MatButtonLazyLoader does not use the\n * MatRipple Directive. In order to create & attach a ripple on demand, it uses the \"lower level\" RippleRenderer.\n */\nclass MatButtonRippleTarget implements RippleTarget {\n  rippleConfig: RippleConfig & RippleGlobalOptions;\n\n  constructor(\n    private _button: HTMLElement,\n    private _globalRippleOptions?: RippleGlobalOptions,\n    animationMode?: string,\n  ) {\n    this._setRippleConfig(_globalRippleOptions, animationMode);\n  }\n\n  private _setRippleConfig(globalRippleOptions?: RippleGlobalOptions, animationMode?: string) {\n    this.rippleConfig = globalRippleOptions || {};\n    if (animationMode === 'NoopAnimations') {\n      this.rippleConfig.animation = {enterDuration: 0, exitDuration: 0};\n    }\n  }\n\n  get rippleDisabled(): boolean {\n    return this._button.hasAttribute('disabled') || !!this._globalRippleOptions?.disabled;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"button-lazy-loader.js","sourceRoot":"","sources":["../../../../../../src/material/button/button-lazy-loader.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAC,QAAQ,EAAC,MAAM,iBAAiB,CAAC;AACzC,OAAO,EACL,qBAAqB,EACrB,UAAU,EACV,UAAU,EACV,MAAM,EAEN,MAAM,GACP,MAAM,eAAe,CAAC;AACvB,OAAO,EAAC,QAAQ,EAAC,MAAM,uBAAuB,CAAC;AAC/C,OAAO,EAAC,yBAAyB,EAAE,SAAS,EAAC,MAAM,wBAAwB,CAAC;;AAE5E,mEAAmE;AACnE,MAAM,oBAAoB,GAAG,EAAC,OAAO,EAAE,IAAI,EAAC,CAAC;AAE7C,uEAAuE;AACvE,MAAM,uBAAuB,GAAG,CAAC,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,YAAY,CAAC,CAAC;AAE/E,uFAAuF;AACvF,MAAM,sBAAsB,GAAG,iCAAiC,CAAC;AAEjE,iFAAiF;AACjF,MAAM,kBAAkB,GAAG,8BAA8B,CAAC;AAE1D,6CAA6C;AAC7C,MAAM,iBAAiB,GAAG,4BAA4B,CAAC;AAEvD,6CAA6C;AAC7C,MAAM,iBAAiB,GAAG,4BAA4B,CAAC;AAEvD;;;;;GAKG;AAEH,MAAM,OAAO,mBAAmB;IAO9B;QANQ,cAAS,GAAG,MAAM,CAAC,QAAQ,EAAE,EAAC,QAAQ,EAAE,IAAI,EAAC,CAAC,CAAC;QAC/C,mBAAc,GAAG,MAAM,CAAC,qBAAqB,EAAE,EAAC,QAAQ,EAAE,IAAI,EAAC,CAAC,CAAC;QACjE,yBAAoB,GAAG,MAAM,CAAC,yBAAyB,EAAE,EAAC,QAAQ,EAAE,IAAI,EAAC,CAAC,CAAC;QAC3E,cAAS,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC;QAC7B,YAAO,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC;QA2EjC,2GAA2G;QACnG,mBAAc,GAAG,CAAC,KAAY,EAAE,EAAE;YACxC,IAAI,CAAC,CAAC,KAAK,CAAC,MAAM,YAAY,WAAW,CAAC,EAAE;gBAC1C,OAAO;aACR;YACD,MAAM,WAAW,GAAG,KAAK,CAAC,MAAqB,CAAC;YAEhD,qFAAqF;YAErF,MAAM,OAAO,GAAG,WAAW,CAAC,OAAO,CAAC,IAAI,sBAAsB,GAAG,CAAC,CAAC;YACnE,IAAI,OAAO,EAAE;gBACX,IAAI,CAAC,YAAY,CAAC,OAAsB,CAAC,CAAC;aAC3C;QACH,CAAC,CAAC;QArFA,IAAI,CAAC,OAAO,CAAC,iBAAiB,CAAC,GAAG,EAAE;YAClC,KAAK,MAAM,KAAK,IAAI,uBAAuB,EAAE;gBAC3C,IAAI,CAAC,SAAS,EAAE,gBAAgB,CAAC,KAAK,EAAE,IAAI,CAAC,cAAc,EAAE,oBAAoB,CAAC,CAAC;aACpF;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IAED,WAAW;QACT,KAAK,MAAM,KAAK,IAAI,uBAAuB,EAAE;YAC3C,IAAI,CAAC,SAAS,EAAE,mBAAmB,CAAC,KAAK,EAAE,IAAI,CAAC,cAAc,EAAE,oBAAoB,CAAC,CAAC;SACvF;IACH,CAAC;IAED;;;;;OAKG;IACH,eAAe,CACb,IAAiB,EACjB,MAIC;QAED,0EAA0E;QAC1E,IAAI,CAAC,YAAY,CAAC,sBAAsB,EAAE,EAAE,CAAC,CAAC;QAE9C,iFAAiF;QACjF,IAAI,MAAM,CAAC,SAAS,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,kBAAkB,CAAC,EAAE;YAC9D,IAAI,CAAC,YAAY,CAAC,kBAAkB,EAAE,MAAM,CAAC,SAAS,IAAI,EAAE,CAAC,CAAC;SAC/D;QAED,+CAA+C;QAC/C,IAAI,MAAM,CAAC,QAAQ,EAAE;YACnB,IAAI,CAAC,YAAY,CAAC,iBAAiB,EAAE,EAAE,CAAC,CAAC;SAC1C;QAED,IAAI,MAAM,CAAC,QAAQ,EAAE;YACnB,IAAI,CAAC,YAAY,CAAC,iBAAiB,EAAE,EAAE,CAAC,CAAC;SAC1C;IACH,CAAC;IAED,8DAA8D;IAC9D,SAAS,CAAC,IAAiB;QACzB,IAAK,IAAY,CAAC,SAAS,EAAE;YAC3B,OAAQ,IAAY,CAAC,SAAS,CAAC;SAChC;QACD,OAAO,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;IACjC,CAAC;IAED,8FAA8F;IAC9F,WAAW,CAAC,IAAiB,EAAE,QAAiB;QAC9C,MAAM,MAAM,GAAI,IAAY,CAAC,SAAkC,CAAC;QAEhE,gEAAgE;QAChE,IAAI,MAAM,EAAE;YACV,MAAM,CAAC,QAAQ,GAAG,QAAQ,CAAC;YAC3B,OAAO;SACR;QAED,kDAAkD;QAClD,2DAA2D;QAC3D,IAAI,QAAQ,EAAE;YACZ,IAAI,CAAC,YAAY,CAAC,iBAAiB,EAAE,EAAE,CAAC,CAAC;SAC1C;aAAM;YACL,IAAI,CAAC,eAAe,CAAC,iBAAiB,CAAC,CAAC;SACzC;IACH,CAAC;IAiBD,+DAA+D;IAC/D,YAAY,CAAC,IAAiB;QAC5B,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE;YACnB,OAAO;SACR;QAED,6BAA6B;QAC7B,IAAI,CAAC,aAAa,CAAC,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;QAC5C,MAAM,QAAQ,GAAG,IAAI,CAAC,SAAU,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC;QACvD,QAAQ,CAAC,SAAS,CAAC,GAAG,CAAC,YAAY,EAAE,IAAI,CAAC,YAAY,CAAC,kBAAkB,CAAE,CAAC,CAAC;QAC7E,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QAEtB,wBAAwB;QACxB,MAAM,MAAM,GAAG,IAAI,SAAS,CAC1B,IAAI,UAAU,CAAC,QAAQ,CAAC,EACxB,IAAI,CAAC,OAAO,EACZ,IAAI,CAAC,SAAS,EACd,IAAI,CAAC,oBAAoB,CAAC,CAAC,CAAC,IAAI,CAAC,oBAAoB,CAAC,CAAC,CAAC,SAAS,EACjE,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC,SAAS,CACtD,CAAC;QACF,MAAM,CAAC,cAAc,GAAG,IAAI,CAAC;QAC7B,MAAM,CAAC,OAAO,GAAG,IAAI,CAAC;QACtB,MAAM,CAAC,QAAQ,GAAG,IAAI,CAAC,YAAY,CAAC,iBAAiB,CAAC,CAAC;QACvD,MAAM,CAAC,QAAQ,GAAG,IAAI,CAAC,YAAY,CAAC,iBAAiB,CAAC,CAAC;QACvD,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QAChC,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,YAAY,CAAC,IAAa,EAAE,MAAiB;QAC3C,IAAI,CAAC,eAAe,CAAC,sBAAsB,CAAC,CAAC;QAC5C,IAAY,CAAC,SAAS,GAAG,MAAM,CAAC;IACnC,CAAC;8GA9HU,mBAAmB;kHAAnB,mBAAmB,cADP,MAAM;;2FAClB,mBAAmB;kBAD/B,UAAU;mBAAC,EAAC,UAAU,EAAE,MAAM,EAAC","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 {DOCUMENT} from '@angular/common';\nimport {\n  ANIMATION_MODULE_TYPE,\n  ElementRef,\n  Injectable,\n  NgZone,\n  OnDestroy,\n  inject,\n} from '@angular/core';\nimport {Platform} from '@angular/cdk/platform';\nimport {MAT_RIPPLE_GLOBAL_OPTIONS, MatRipple} from '@angular/material/core';\n\n/** The options for the MatButtonRippleLoader's event listeners. */\nconst eventListenerOptions = {capture: true};\n\n/** The events that should trigger the initialization of the ripple. */\nconst rippleInteractionEvents = ['focus', 'click', 'mouseenter', 'touchstart'];\n\n/** The attribute attached to a component whose ripple has not yet been initialized. */\nconst matRippleUninitialized = 'mat-ripple-loader-uninitialized';\n\n/** Additional classes that should be added to the ripple when it is rendered. */\nconst matRippleClassName = 'mat-ripple-loader-class-name';\n\n/** Whether the ripple should be centered. */\nconst matRippleCentered = 'mat-ripple-loader-centered';\n\n/** Whether the ripple should be disabled. */\nconst matRippleDisabled = 'mat-ripple-loader-disabled';\n\n/**\n * Handles attaching ripples on demand.\n *\n * This service allows us to avoid eagerly creating & attaching MatRipples.\n * It works by creating & attaching a ripple only when a component is first interacted with.\n */\n@Injectable({providedIn: 'root'})\nexport class MatButtonLazyLoader implements OnDestroy {\n  private _document = inject(DOCUMENT, {optional: true});\n  private _animationMode = inject(ANIMATION_MODULE_TYPE, {optional: true});\n  private _globalRippleOptions = inject(MAT_RIPPLE_GLOBAL_OPTIONS, {optional: true});\n  private _platform = inject(Platform);\n  private _ngZone = inject(NgZone);\n\n  constructor() {\n    this._ngZone.runOutsideAngular(() => {\n      for (const event of rippleInteractionEvents) {\n        this._document?.addEventListener(event, this._onInteraction, eventListenerOptions);\n      }\n    });\n  }\n\n  ngOnDestroy() {\n    for (const event of rippleInteractionEvents) {\n      this._document?.removeEventListener(event, this._onInteraction, eventListenerOptions);\n    }\n  }\n\n  /**\n   * Configures the ripple that will be rendered by the ripple loader.\n   *\n   * Stores the given information about how the ripple should be configured on the host\n   * element so that it can later be retrived & used when the ripple is actually created.\n   */\n  configureRipple(\n    host: HTMLElement,\n    config: {\n      className?: string;\n      centered?: boolean;\n      disabled?: boolean;\n    },\n  ): void {\n    // Indicates that the ripple has not yet been rendered for this component.\n    host.setAttribute(matRippleUninitialized, '');\n\n    // Store the additional class name(s) that should be added to the ripple element.\n    if (config.className || !host.hasAttribute(matRippleClassName)) {\n      host.setAttribute(matRippleClassName, config.className || '');\n    }\n\n    // Store whether the ripple should be centered.\n    if (config.centered) {\n      host.setAttribute(matRippleCentered, '');\n    }\n\n    if (config.disabled) {\n      host.setAttribute(matRippleDisabled, '');\n    }\n  }\n\n  /** Returns the ripple instance for the given host element. */\n  getRipple(host: HTMLElement): MatRipple | undefined {\n    if ((host as any).matRipple) {\n      return (host as any).matRipple;\n    }\n    return this.createRipple(host);\n  }\n\n  /** Sets the disabled state on the ripple instance corresponding to the given host element. */\n  setDisabled(host: HTMLElement, disabled: boolean): void {\n    const ripple = (host as any).matRipple as MatRipple | undefined;\n\n    // If the ripple has already been instantiated, just disable it.\n    if (ripple) {\n      ripple.disabled = disabled;\n      return;\n    }\n\n    // Otherwise, set an attribute so we know what the\n    // disabled state should be when the ripple is initialized.\n    if (disabled) {\n      host.setAttribute(matRippleDisabled, '');\n    } else {\n      host.removeAttribute(matRippleDisabled);\n    }\n  }\n\n  /** Handles creating and attaching component internals when a component it is initially interacted with. */\n  private _onInteraction = (event: Event) => {\n    if (!(event.target instanceof HTMLElement)) {\n      return;\n    }\n    const eventTarget = event.target as HTMLElement;\n\n    // TODO(wagnermaciel): Consider batching these events to improve runtime performance.\n\n    const element = eventTarget.closest(`[${matRippleUninitialized}]`);\n    if (element) {\n      this.createRipple(element as HTMLElement);\n    }\n  };\n\n  /** Creates a MatRipple and appends it to the given element. */\n  createRipple(host: HTMLElement): MatRipple | undefined {\n    if (!this._document) {\n      return;\n    }\n\n    // Create the ripple element.\n    host.querySelector('.mat-ripple')?.remove();\n    const rippleEl = this._document!.createElement('span');\n    rippleEl.classList.add('mat-ripple', host.getAttribute(matRippleClassName)!);\n    host.append(rippleEl);\n\n    // Create the MatRipple.\n    const ripple = new MatRipple(\n      new ElementRef(rippleEl),\n      this._ngZone,\n      this._platform,\n      this._globalRippleOptions ? this._globalRippleOptions : undefined,\n      this._animationMode ? this._animationMode : undefined,\n    );\n    ripple._isInitialized = true;\n    ripple.trigger = host;\n    ripple.centered = host.hasAttribute(matRippleCentered);\n    ripple.disabled = host.hasAttribute(matRippleDisabled);\n    this.attachRipple(host, ripple);\n    return ripple;\n  }\n\n  attachRipple(host: Element, ripple: MatRipple): void {\n    host.removeAttribute(matRippleUninitialized);\n    (host as any).matRipple = ripple;\n  }\n}\n"]}