@angular/material 16.1.0 → 16.2.0-next.0

package/button/index.d.ts

@@ -11,8 +11,8 @@ import * as i0 from '@angular/core';
 import * as i4 from '@angular/material/core';
 import { InjectionToken } from '@angular/core';
 import { MatRipple } from '@angular/material/core';
+import { MatRippleLoader } 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 +95,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;
@@ -104,7 +104,7 @@ declare class MatButtonBase extends _MatButtonMixin implements CanDisable, CanCo
      * Handles the lazy creation of the MatButton ripple.
      * Used to improve initial load time of large applications.
      */
-    _rippleLoader: MatButtonLazyLoader;
+    _rippleLoader: MatRippleLoader;
     /** Whether this button is a FAB. Used to apply the correct class on the ripple. */
     _isFab: boolean;
     /**
@@ -114,43 +114,25 @@ 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, false>;
 }
 
-/**
- * Handles attaching the MatButton's ripple 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.
- */
-declare class MatButtonLazyLoader implements OnDestroy {
-    private _document;
-    private _animationMode;
-    private _globalRippleOptions;
-    private _platform;
-    private _ngZone;
-    constructor();
-    ngOnDestroy(): void;
-    /** Handles creating and attaching button internals when a button is initially interacted with. */
-    private _onInteraction;
-    /** Creates a MatButtonRipple and appends it to the given button element. */
-    private _appendRipple;
-    _createMatRipple(button: HTMLElement): MatRipple | undefined;
-    static ɵfac: i0.ɵɵFactoryDeclaration<MatButtonLazyLoader, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<MatButtonLazyLoader>;
-}
-
 /** @docs-private */
 declare const _MatButtonMixin: _Constructor<CanColor> & _AbstractConstructor<CanColor> & _Constructor<CanDisable> & _AbstractConstructor<CanDisable> & _Constructor<CanDisableRipple> & _AbstractConstructor<CanDisableRipple> & {
     new (_elementRef: ElementRef): {
@@ -222,12 +204,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, false>;

package/card/_card-theme.scss

@@ -79,11 +79,8 @@
 }
 
 @mixin theme-from-tokens($tokens) {
-  // Add values for card tokens.
-  .mat-mdc-card {
-    @include mdc-elevated-card-theme.theme(map.get($tokens, tokens-mdc-elevated-card.$prefix));
-    @include mdc-outlined-card-theme.theme(map.get($tokens, tokens-mdc-outlined-card.$prefix));
-    @include token-utils.create-token-values(
-        tokens-mat-card.$prefix, map.get($tokens, tokens-mat-card.$prefix));
-  }
+  @include mdc-elevated-card-theme.theme(map.get($tokens, tokens-mdc-elevated-card.$prefix));
+  @include mdc-outlined-card-theme.theme(map.get($tokens, tokens-mdc-outlined-card.$prefix));
+  @include token-utils.create-token-values(
+      tokens-mat-card.$prefix, map.get($tokens, tokens-mat-card.$prefix));
 }

package/checkbox/_checkbox-theme.scss

@@ -92,8 +92,5 @@
 @mixin theme-from-tokens($tokens) {
   // TODO(mmalerba): Some of the theme styles above are not represented in terms of tokens,
   //   so this mixin is currently incomplete.
-
-  .mat-mdc-checkbox {
-    @include mdc-checkbox-theme.theme(map.get($tokens, tokens-mdc-checkbox.$prefix));
-  }
+  @include mdc-checkbox-theme.theme(map.get($tokens, tokens-mdc-checkbox.$prefix));
 }

package/core/index.d.ts

@@ -797,6 +797,43 @@ export declare class MatRipple implements OnInit, OnDestroy, RippleTarget {
     static ɵdir: i0.ɵɵDirectiveDeclaration<MatRipple, "[mat-ripple], [matRipple]", ["matRipple"], { "color": { "alias": "matRippleColor"; "required": false; }; "unbounded": { "alias": "matRippleUnbounded"; "required": false; }; "centered": { "alias": "matRippleCentered"; "required": false; }; "radius": { "alias": "matRippleRadius"; "required": false; }; "animation": { "alias": "matRippleAnimation"; "required": false; }; "disabled": { "alias": "matRippleDisabled"; "required": false; }; "trigger": { "alias": "matRippleTrigger"; "required": false; }; }, {}, never, never, false, never, false>;
 }
 
+/**
+ * Handles attaching ripples on demand.
+ *
+ * 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 declare class MatRippleLoader implements OnDestroy {
+    private _document;
+    private _animationMode;
+    private _globalRippleOptions;
+    private _platform;
+    private _ngZone;
+    constructor();
+    ngOnDestroy(): void;
+    /**
+     * 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;
+    }): 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 MatRipple and appends it to the given element. */
+    createRipple(host: HTMLElement): MatRipple | undefined;
+    attachRipple(host: Element, ripple: MatRipple): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatRippleLoader, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MatRippleLoader>;
+}
+
 export declare class MatRippleModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<MatRippleModule, never>;
     static ɵmod: i0.ɵɵNgModuleDeclaration<MatRippleModule, [typeof i1_4.MatRipple], [typeof i1_2.MatCommonModule], [typeof i1_4.MatRipple, typeof i1_2.MatCommonModule]>;

package/core/style/_sass-utils.scss

@@ -14,6 +14,18 @@
   }
 }
 
+/// A version of the standard `map.merge` function that takes a variable number of arguments.
+/// Each argument is merged into the final result from left to right.
+/// @param {List} $maps The maps to combine with map.merge
+/// @return {Map} The combined result of successively calling map.merge with each parameter.
+@function merge-all($maps...) {
+  $result: ();
+  @each $map in $maps {
+    $result: map.merge($result, $map);
+  }
+  @return $result;
+}
+
 /// A version of the standard `map.deep-merge` function that takes a variable number of arguments.
 /// Each argument is deep-merged into the final result from left to right.
 /// @param {List} $maps The maps to combine with map.deep-merge

package/core/tokens/_token-utils.scss

@@ -71,12 +71,21 @@ $_component-prefix: null;
 
 // Emits a slot for the given token, provided that it has a non-null value in the token map passed
 // to `use-tokens`.
-@mixin create-token-slot($property, $token) {
+@mixin create-token-slot($property, $token, $emit-fallback: false) {
   @if $_component-prefix == null or $_tokens == null {
     @error '`create-token-slot` must be used within `use-tokens`';
   }
   @if map.get($_tokens, $token) != null {
-    $value: mdc-custom-properties.create('#{$_component-prefix}-#{$token}');
+    $fallback: null;
+
+    @if ($emit-fallback == true) {
+      $fallback: map.get($_tokens, $token);
+    }
+    @else if ($emit-fallback) {
+      $fallback: $emit-fallback;
+    }
+
+    $value: mdc-custom-properties.create('#{$_component-prefix}-#{$token}', $fallback: $fallback);
     @include mdc-theme.property($property, $value);
   }
 }

package/core/tokens/m2/mat/_table.scss

@@ -0,0 +1,97 @@
+@use 'sass:map';
+@use '../../../theming/theming';
+@use '../../../typography/typography-utils';
+@use '../../token-utils';
+@use '../../../style/sass-utils';
+
+// The prefix used to generate the fully qualified name for tokens in this file.
+$prefix: (mat, table);
+
+// 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 (
+    row-item-outline-width: 1px,
+  );
+}
+
+// Tokens that can be configured through Angular Material's color theming API.
+@function get-color-tokens($config) {
+  $foreground: map.get($config, foreground);
+  $background: map.get($config, background);
+
+  @return (
+    background-color: theming.get-color-from-palette($background, 'card'),
+
+    header-headline-color: theming.get-color-from-palette($foreground, text),
+    row-item-label-text-color: theming.get-color-from-palette($foreground, text),
+    row-item-outline-color: theming.get-color-from-palette($foreground, divider),
+  );
+}
+
+// Tokens that can be configured through Angular Material's typography theming API.
+@function get-typography-tokens($config) {
+  $fallback-font: typography-utils.font-family($config);
+  $cell-font-family: typography-utils.font-family($config, body-2) or $fallback-font;
+  $cell-line-height: typography-utils.line-height($config, body-2);
+  $cell-font-size: typography-utils.font-size($config, body-2);
+  $cell-font-weight: typography-utils.font-weight($config, body-2);
+  $cell-letter-spacing: typography-utils.letter-spacing($config, body-2);
+
+  @return (
+    header-headline-font: typography-utils.font-family($config, subtitle-2) or $fallback-font,
+    header-headline-line-height: typography-utils.line-height($config, subtitle-2),
+    header-headline-size: typography-utils.font-size($config, subtitle-2),
+    header-headline-weight: typography-utils.font-weight($config, subtitle-2),
+    header-headline-tracking: typography-utils.letter-spacing($config, subtitle-2),
+
+    // Plain cells and footer cells have the same typography.
+    row-item-label-text-font: $cell-font-family,
+    row-item-label-text-line-height: $cell-line-height,
+    row-item-label-text-size: $cell-font-size,
+    row-item-label-text-weight: $cell-font-weight,
+    row-item-label-text-tracking: $cell-letter-spacing,
+
+    footer-supporting-text-font: $cell-font-family,
+    footer-supporting-text-line-height: $cell-line-height,
+    footer-supporting-text-size: $cell-font-size,
+    footer-supporting-text-weight: $cell-font-weight,
+    footer-supporting-text-tracking: $cell-letter-spacing,
+  );
+}
+
+// Tokens that can be configured through Angular Material's density theming API.
+@function get-density-tokens($config) {
+  $scale: theming.clamp-density($config, -4);
+  $header-scale: (
+    0: 56px,
+    -1: 52px,
+    -2: 48px,
+    -3: 44px,
+    -4: 40px
+  );
+  $cell-scale: (
+    0: 52px,
+    -1: 48px,
+    -2: 44px,
+    -3: 40px,
+    -4: 36px
+  );
+
+  @return (
+    header-container-height: map.get($header-scale, $scale),
+    footer-container-height: map.get($cell-scale, $scale),
+    row-item-container-height: map.get($cell-scale, $scale),
+  );
+}
+
+// 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/esm2022/button/button-base.mjs

@@ -6,10 +6,10 @@
  * 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 { mixinColor, mixinDisabled, mixinDisableRipple, MatRippleLoader, } from '@angular/material/core';
 import * as i0 from "@angular/core";
 import * as i1 from "@angular/cdk/platform";
 /** Inputs common to all buttons. */
@@ -25,7 +25,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 +72,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);
@@ -91,9 +104,14 @@ export class MatButtonBase extends _MatButtonMixin {
          * Handles the lazy creation of the MatButton ripple.
          * Used to improve initial load time of large applications.
          */
-        this._rippleLoader = inject(MatButtonLazyLoader);
+        this._rippleLoader = inject(MatRippleLoader);
         /** 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 +126,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 +142,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.0-next.3", ngImport: i0, type: MatButtonBase, deps: "invalid", target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.1.0-next.3", type: MatButtonBase, usesInheritance: true, usesOnChanges: true, ngImport: i0 }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.1.0-next.3", type: MatButtonBase, usesInheritance: true, ngImport: i0 }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.0-next.3", ngImport: i0, type: MatButtonBase, decorators: [{
             type: Directive
@@ -153,7 +169,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 +199,4 @@ export class MatAnchorBase extends MatButtonBase {
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.0-next.3", 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":"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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 {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  MatRippleLoader,\n} from '@angular/material/core';\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: MatRippleLoader = inject(MatRippleLoader);\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"]}