@angular/material
Version:
Angular Material
263 lines • 22 kB
JavaScript
/**
* @fileoverview added by tsickle
* Generated from: src/material/core/ripple/ripple.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @license
* Copyright Google LLC All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://angular.io/license
*/
import { Platform } from '@angular/cdk/platform';
import { Directive, ElementRef, Inject, InjectionToken, Input, NgZone, Optional, } from '@angular/core';
import { RippleRenderer } from './ripple-renderer';
import { ANIMATION_MODULE_TYPE } from '@angular/platform-browser/animations';
/**
* Configurable options for `matRipple`.
* @record
*/
export function RippleGlobalOptions() { }
if (false) {
/**
* Whether ripples should be disabled. Ripples can be still launched manually by using
* the `launch()` method. Therefore focus indicators will still show up.
* @type {?|undefined}
*/
RippleGlobalOptions.prototype.disabled;
/**
* Configuration for the animation duration of the ripples. There are two phases with different
* durations for the ripples. The animation durations will be overwritten if the
* `NoopAnimationsModule` is being used.
* @type {?|undefined}
*/
RippleGlobalOptions.prototype.animation;
/**
* Whether ripples should start fading out immediately after the mouse or touch is released. By
* default, ripples will wait for the enter animation to complete and for mouse or touch release.
* @type {?|undefined}
*/
RippleGlobalOptions.prototype.terminateOnPointerUp;
}
/**
* Injection token that can be used to specify the global ripple options.
* @type {?}
*/
export const MAT_RIPPLE_GLOBAL_OPTIONS = new InjectionToken('mat-ripple-global-options');
export class MatRipple {
/**
* @param {?} _elementRef
* @param {?} ngZone
* @param {?} platform
* @param {?=} globalOptions
* @param {?=} animationMode
*/
constructor(_elementRef, ngZone, platform, globalOptions, animationMode) {
this._elementRef = _elementRef;
/**
* If set, the radius in pixels of foreground ripples when fully expanded. If unset, the radius
* will be the distance from the center of the ripple to the furthest corner of the host element's
* bounding rectangle.
*/
this.radius = 0;
this._disabled = false;
/**
* Whether ripple directive is initialized and the input bindings are set.
*/
this._isInitialized = false;
this._globalOptions = globalOptions || {};
this._rippleRenderer = new RippleRenderer(this, ngZone, _elementRef, platform);
if (animationMode === 'NoopAnimations') {
this._globalOptions.animation = { enterDuration: 0, exitDuration: 0 };
}
}
/**
* Whether click events will not trigger the ripple. Ripples can be still launched manually
* by using the `launch()` method.
* @return {?}
*/
get disabled() { return this._disabled; }
/**
* @param {?} value
* @return {?}
*/
set disabled(value) {
this._disabled = value;
this._setupTriggerEventsIfEnabled();
}
/**
* The element that triggers the ripple when click events are received.
* Defaults to the directive's host element.
* @return {?}
*/
get trigger() { return this._trigger || this._elementRef.nativeElement; }
/**
* @param {?} trigger
* @return {?}
*/
set trigger(trigger) {
this._trigger = trigger;
this._setupTriggerEventsIfEnabled();
}
/**
* @return {?}
*/
ngOnInit() {
this._isInitialized = true;
this._setupTriggerEventsIfEnabled();
}
/**
* @return {?}
*/
ngOnDestroy() {
this._rippleRenderer._removeTriggerEvents();
}
/**
* Fades out all currently showing ripple elements.
* @return {?}
*/
fadeOutAll() {
this._rippleRenderer.fadeOutAll();
}
/**
* Ripple configuration from the directive's input values.
* \@docs-private Implemented as part of RippleTarget
* @return {?}
*/
get rippleConfig() {
return {
centered: this.centered,
radius: this.radius,
color: this.color,
animation: Object.assign(Object.assign({}, this._globalOptions.animation), this.animation),
terminateOnPointerUp: this._globalOptions.terminateOnPointerUp,
};
}
/**
* Whether ripples on pointer-down are disabled or not.
* \@docs-private Implemented as part of RippleTarget
* @return {?}
*/
get rippleDisabled() {
return this.disabled || !!this._globalOptions.disabled;
}
/**
* Sets up the trigger event listeners if ripples are enabled.
* @private
* @return {?}
*/
_setupTriggerEventsIfEnabled() {
if (!this.disabled && this._isInitialized) {
this._rippleRenderer.setupTriggerEvents(this.trigger);
}
}
/**
* Launches a manual ripple at the specified coordinated or just by the ripple config.
* @param {?} configOrX
* @param {?=} y
* @param {?=} config
* @return {?}
*/
launch(configOrX, y = 0, config) {
if (typeof configOrX === 'number') {
return this._rippleRenderer.fadeInRipple(configOrX, y, Object.assign(Object.assign({}, this.rippleConfig), config));
}
else {
return this._rippleRenderer.fadeInRipple(0, 0, Object.assign(Object.assign({}, this.rippleConfig), configOrX));
}
}
}
MatRipple.decorators = [
{ type: Directive, args: [{
selector: '[mat-ripple], [matRipple]',
exportAs: 'matRipple',
host: {
'class': 'mat-ripple',
'[class.mat-ripple-unbounded]': 'unbounded'
}
},] }
];
/** @nocollapse */
MatRipple.ctorParameters = () => [
{ type: ElementRef },
{ type: NgZone },
{ type: Platform },
{ type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [MAT_RIPPLE_GLOBAL_OPTIONS,] }] },
{ type: String, decorators: [{ type: Optional }, { type: Inject, args: [ANIMATION_MODULE_TYPE,] }] }
];
MatRipple.propDecorators = {
color: [{ type: Input, args: ['matRippleColor',] }],
unbounded: [{ type: Input, args: ['matRippleUnbounded',] }],
centered: [{ type: Input, args: ['matRippleCentered',] }],
radius: [{ type: Input, args: ['matRippleRadius',] }],
animation: [{ type: Input, args: ['matRippleAnimation',] }],
disabled: [{ type: Input, args: ['matRippleDisabled',] }],
trigger: [{ type: Input, args: ['matRippleTrigger',] }]
};
if (false) {
/**
* Custom color for all ripples.
* @type {?}
*/
MatRipple.prototype.color;
/**
* Whether the ripples should be visible outside the component's bounds.
* @type {?}
*/
MatRipple.prototype.unbounded;
/**
* Whether the ripple always originates from the center of the host element's bounds, rather
* than originating from the location of the click event.
* @type {?}
*/
MatRipple.prototype.centered;
/**
* If set, the radius in pixels of foreground ripples when fully expanded. If unset, the radius
* will be the distance from the center of the ripple to the furthest corner of the host element's
* bounding rectangle.
* @type {?}
*/
MatRipple.prototype.radius;
/**
* Configuration for the ripple animation. Allows modifying the enter and exit animation
* duration of the ripples. The animation durations will be overwritten if the
* `NoopAnimationsModule` is being used.
* @type {?}
*/
MatRipple.prototype.animation;
/**
* @type {?}
* @private
*/
MatRipple.prototype._disabled;
/**
* @type {?}
* @private
*/
MatRipple.prototype._trigger;
/**
* Renderer for the ripple DOM manipulations.
* @type {?}
* @private
*/
MatRipple.prototype._rippleRenderer;
/**
* Options that are set globally for all ripples.
* @type {?}
* @private
*/
MatRipple.prototype._globalOptions;
/**
* Whether ripple directive is initialized and the input bindings are set.
* @type {?}
* @private
*/
MatRipple.prototype._isInitialized;
/**
* @type {?}
* @private
*/
MatRipple.prototype._elementRef;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ripple.js","sourceRoot":"","sources":["../../../../../../../src/material/core/ripple/ripple.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 {Platform} from '@angular/cdk/platform';\nimport {\n  Directive,\n  ElementRef,\n  Inject,\n  InjectionToken,\n  Input,\n  NgZone,\n  OnDestroy,\n  OnInit,\n  Optional,\n} from '@angular/core';\nimport {RippleRef} from './ripple-ref';\nimport {RippleAnimationConfig, RippleConfig, RippleRenderer, RippleTarget} from './ripple-renderer';\nimport {ANIMATION_MODULE_TYPE} from '@angular/platform-browser/animations';\n\n/** Configurable options for `matRipple`. */\nexport interface RippleGlobalOptions {\n  /**\n   * Whether ripples should be disabled. Ripples can be still launched manually by using\n   * the `launch()` method. Therefore focus indicators will still show up.\n   */\n  disabled?: boolean;\n\n  /**\n   * Configuration for the animation duration of the ripples. There are two phases with different\n   * durations for the ripples. The animation durations will be overwritten if the\n   * `NoopAnimationsModule` is being used.\n   */\n  animation?: RippleAnimationConfig;\n\n  /**\n   * Whether ripples should start fading out immediately after the mouse or touch is released. By\n   * default, ripples will wait for the enter animation to complete and for mouse or touch release.\n   */\n  terminateOnPointerUp?: boolean;\n}\n\n/** Injection token that can be used to specify the global ripple options. */\nexport const MAT_RIPPLE_GLOBAL_OPTIONS =\n    new InjectionToken<RippleGlobalOptions>('mat-ripple-global-options');\n\n@Directive({\n  selector: '[mat-ripple], [matRipple]',\n  exportAs: 'matRipple',\n  host: {\n    'class': 'mat-ripple',\n    '[class.mat-ripple-unbounded]': 'unbounded'\n  }\n})\nexport class MatRipple implements OnInit, OnDestroy, RippleTarget {\n\n  /** Custom color for all ripples. */\n  @Input('matRippleColor') color: string;\n\n  /** Whether the ripples should be visible outside the component's bounds. */\n  @Input('matRippleUnbounded') unbounded: boolean;\n\n  /**\n   * Whether the ripple always originates from the center of the host element's bounds, rather\n   * than originating from the location of the click event.\n   */\n  @Input('matRippleCentered') centered: boolean;\n\n  /**\n   * If set, the radius in pixels of foreground ripples when fully expanded. If unset, the radius\n   * will be the distance from the center of the ripple to the furthest corner of the host element's\n   * bounding rectangle.\n   */\n  @Input('matRippleRadius') radius: number = 0;\n\n  /**\n   * Configuration for the ripple animation. Allows modifying the enter and exit animation\n   * duration of the ripples. The animation durations will be overwritten if the\n   * `NoopAnimationsModule` is being used.\n   */\n  @Input('matRippleAnimation') animation: RippleAnimationConfig;\n\n  /**\n   * Whether click events will not trigger the ripple. Ripples can be still launched manually\n   * by using the `launch()` method.\n   */\n  @Input('matRippleDisabled')\n  get disabled() { return this._disabled; }\n  set disabled(value: boolean) {\n    this._disabled = value;\n    this._setupTriggerEventsIfEnabled();\n  }\n  private _disabled: boolean = false;\n\n  /**\n   * The element that triggers the ripple when click events are received.\n   * Defaults to the directive's host element.\n   */\n  @Input('matRippleTrigger')\n  get trigger() { return this._trigger || this._elementRef.nativeElement; }\n  set trigger(trigger: HTMLElement) {\n    this._trigger = trigger;\n    this._setupTriggerEventsIfEnabled();\n  }\n  private _trigger: HTMLElement;\n\n  /** Renderer for the ripple DOM manipulations. */\n  private _rippleRenderer: RippleRenderer;\n\n  /** Options that are set globally for all ripples. */\n  private _globalOptions: RippleGlobalOptions;\n\n  /** Whether ripple directive is initialized and the input bindings are set. */\n  private _isInitialized: boolean = false;\n\n  constructor(private _elementRef: ElementRef<HTMLElement>,\n              ngZone: NgZone,\n              platform: Platform,\n              @Optional() @Inject(MAT_RIPPLE_GLOBAL_OPTIONS) globalOptions?: RippleGlobalOptions,\n              @Optional() @Inject(ANIMATION_MODULE_TYPE) animationMode?: string) {\n\n    this._globalOptions = globalOptions || {};\n    this._rippleRenderer = new RippleRenderer(this, ngZone, _elementRef, platform);\n\n    if (animationMode === 'NoopAnimations') {\n      this._globalOptions.animation = {enterDuration: 0, exitDuration: 0};\n    }\n  }\n\n  ngOnInit() {\n    this._isInitialized = true;\n    this._setupTriggerEventsIfEnabled();\n  }\n\n  ngOnDestroy() {\n    this._rippleRenderer._removeTriggerEvents();\n  }\n\n  /** Fades out all currently showing ripple elements. */\n  fadeOutAll() {\n    this._rippleRenderer.fadeOutAll();\n  }\n\n  /**\n   * Ripple configuration from the directive's input values.\n   * @docs-private Implemented as part of RippleTarget\n   */\n  get rippleConfig(): RippleConfig {\n    return {\n      centered: this.centered,\n      radius: this.radius,\n      color: this.color,\n      animation: {...this._globalOptions.animation, ...this.animation},\n      terminateOnPointerUp: this._globalOptions.terminateOnPointerUp,\n    };\n  }\n\n  /**\n   * Whether ripples on pointer-down are disabled or not.\n   * @docs-private Implemented as part of RippleTarget\n   */\n  get rippleDisabled(): boolean {\n    return this.disabled || !!this._globalOptions.disabled;\n  }\n\n  /** Sets up the trigger event listeners if ripples are enabled. */\n  private _setupTriggerEventsIfEnabled() {\n    if (!this.disabled && this._isInitialized) {\n      this._rippleRenderer.setupTriggerEvents(this.trigger);\n    }\n  }\n\n  /**\n   * Launches a manual ripple using the specified ripple configuration.\n   * @param config Configuration for the manual ripple.\n   */\n  launch(config: RippleConfig): RippleRef;\n\n  /**\n   * Launches a manual ripple at the specified coordinates within the element.\n   * @param x Coordinate within the element, along the X axis at which to fade-in the ripple.\n   * @param y Coordinate within the element, along the Y axis at which to fade-in the ripple.\n   * @param config Optional ripple configuration for the manual ripple.\n   */\n  launch(x: number, y: number, config?: RippleConfig): RippleRef;\n\n  /** Launches a manual ripple at the specified coordinated or just by the ripple config. */\n  launch(configOrX: number | RippleConfig, y: number = 0, config?: RippleConfig): RippleRef {\n    if (typeof configOrX === 'number') {\n      return this._rippleRenderer.fadeInRipple(configOrX, y, {...this.rippleConfig, ...config});\n    } else {\n      return this._rippleRenderer.fadeInRipple(0, 0, {...this.rippleConfig, ...configOrX});\n    }\n  }\n}\n\n"]}