@blox/material
Version:
Material Components for Angular
155 lines • 18.2 kB
JavaScript
import { Directive, ElementRef, HostBinding, Input, Renderer2, Inject } from '@angular/core';
import { DOCUMENT } from '@angular/common';
import { asBoolean, asBooleanOrNull } from '../../utils/value.utils';
import { AbstractMdcRipple } from '../ripple/abstract.mdc.ripple';
import { MdcEventRegistry } from '../../utils/mdc.event.registry';
/**
* Directive for making an element a ripple surface. The ripple can be customized
* with the provided
* <a href="https://github.com/material-components/material-components-web/tree/master/packages/mdc-ripple#sass-apis"
* target="_blank">Sass Mixins</a>.
* Alternatively you can set the <code>surface</code> to get a default styled ripple.
*/
export class MdcRippleDirective extends AbstractMdcRipple {
constructor(_elm, renderer, registry, doc) {
super(_elm, renderer, registry, doc);
this._elm = _elm;
this._initialized = false;
this._on = false;
this._disabled = null;
this._surface = false;
this._dim = null;
}
ngAfterContentInit() {
if (this._on)
this.initRipple();
this._initialized = true;
}
ngOnDestroy() {
this.destroyRipple();
}
/** @internal */
isRippleSurfaceDisabled() {
return this._disabled == null ? super.isRippleSurfaceDisabled() : this._disabled;
}
/** @internal */
computeRippleBoundingRect() {
if (this._dim == null)
return super.computeRippleBoundingRect();
const { left, top } = this._elm.nativeElement.getBoundingClientRect();
return {
left,
top,
width: this._dim,
height: this._dim,
right: left + this._dim,
bottom: top + this._dim,
};
}
/**
* Set this input to false to remove the ripple effect from the surface.
*/
get mdcRipple() {
return this._on;
}
set mdcRipple(value) {
const newValue = asBoolean(value);
if (newValue !== this._on) {
this._on = newValue;
if (this._initialized) {
if (newValue)
this.initRipple();
else
this.destroyRipple();
}
}
}
/**
* When this input has a value other than false, the ripple is unbounded.
* Surfaces for bounded ripples should have <code>overflow</code> set to hidden,
* while surfaces for unbounded ripples should have it set to <code>visible</code>.
*/
get unbounded() {
return this.isRippleUnbounded();
}
set unbounded(value) {
this.setRippleUnbounded(asBoolean(value));
}
/** @internal */
get _attrUnbounded() {
return this.unbounded ? "" : null;
}
/**
* This input sets the dimension of the ripple.
* This input can be set to null for returning to the defaults, which uses the surface
* element to compute the bounds of the ripple.
*/
get dimension() {
return this._dim;
}
set dimension(value) {
this._dim = value == null ? null : +value;
this.layout();
}
/**
* This input can be used to programmatically enable/disable the ripple.
* When true, the ripple effect will be disabled, when false the ripple
* effect will be enabled. When not set, or <code>null</code> (default)
* the ripple effect enabled/disabled state depend on whether or not the
* surface element has the <code>disabled</code> attribute set.
*/
get disabled() {
return this._disabled;
}
set disabled(value) {
this._disabled = asBooleanOrNull(value);
}
/**
* When this input has a value other than false, the ripple element will get the
* "mdc-ripple-surface" class. That class has styling for bounded and unbounded
* ripples in accordance with your theme customizations. Without this property,
* you have to supply your own ripple styles, using the provided
* <a href="https://github.com/material-components/material-components-web/tree/master/packages/mdc-ripple#sass-apis"
* target="_blank">Sass Mixins</a>.
*
* To apply a standard surface ripple, set the value to `true`, `"primary"`, or `"accent"`.
* The values primary and accent set the ripple color to the theme primary or secondary color.
*/
get surface() {
return !!this._surface;
}
set surface(value) {
if (value === 'primary' || value === 'accent')
this._surface = value;
else
this._surface = asBoolean(value);
}
get _surfacePrimary() {
return this._surface === 'primary';
}
get _surfaceAccent() {
return this._surface === 'accent';
}
}
MdcRippleDirective.decorators = [
{ type: Directive, args: [{
selector: '[mdcRipple]'
},] }
];
MdcRippleDirective.ctorParameters = () => [
{ type: ElementRef },
{ type: Renderer2 },
{ type: MdcEventRegistry },
{ type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] }
];
MdcRippleDirective.propDecorators = {
mdcRipple: [{ type: Input }],
unbounded: [{ type: Input }],
_attrUnbounded: [{ type: HostBinding, args: ['attr.data-mdc-ripple-is-unbounded',] }],
dimension: [{ type: Input }],
disabled: [{ type: Input }],
surface: [{ type: Input }, { type: HostBinding, args: ['class.mdc-ripple-surface',] }],
_surfacePrimary: [{ type: HostBinding, args: ['class.mdc-ripple-surface--primary',] }],
_surfaceAccent: [{ type: HostBinding, args: ['class.mdc-ripple-surface--accent',] }]
};
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"mdc.ripple.directive.js","sourceRoot":"","sources":["../../../../src/components/ripple/mdc.ripple.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { AfterContentInit, Directive, ElementRef, HostBinding, Input, OnDestroy, Renderer2, Inject } from '@angular/core';\r\nimport { DOCUMENT } from '@angular/common';\r\nimport { asBoolean, asBooleanOrNull } from '../../utils/value.utils';\r\nimport { AbstractMdcRipple } from '../ripple/abstract.mdc.ripple';\r\nimport { MdcEventRegistry } from '../../utils/mdc.event.registry';\r\n\r\n/**\r\n * Directive for making an element a ripple surface. The ripple can be customized\r\n * with the provided\r\n * <a href=\"https://github.com/material-components/material-components-web/tree/master/packages/mdc-ripple#sass-apis\"\r\n *   target=\"_blank\">Sass Mixins</a>.\r\n * Alternatively you can set the <code>surface</code> to get a default styled ripple.\r\n */\r\n@Directive({\r\n    selector: '[mdcRipple]'\r\n})\r\nexport class MdcRippleDirective extends AbstractMdcRipple implements AfterContentInit, OnDestroy {\r\n    private _initialized = false;\r\n    private _on = false;\r\n    private _disabled: boolean | null = null;\r\n    private _surface: boolean | 'primary' | 'accent' = false;\r\n    private _dim: number | null = null;\r\n\r\n    constructor(public _elm: ElementRef, renderer: Renderer2, registry: MdcEventRegistry, @Inject(DOCUMENT) doc: any) {\r\n        super(_elm, renderer, registry, doc as Document);\r\n    }\r\n  \r\n    ngAfterContentInit() {\r\n        if (this._on)\r\n            this.initRipple();\r\n        this._initialized = true;\r\n    }\r\n  \r\n    ngOnDestroy() {\r\n        this.destroyRipple();\r\n    }\r\n\r\n    /** @internal */\r\n    protected isRippleSurfaceDisabled() {\r\n        return this._disabled == null ? super.isRippleSurfaceDisabled() : this._disabled;\r\n    }\r\n\r\n    /** @internal */\r\n    protected computeRippleBoundingRect() {\r\n        if (this._dim == null)\r\n            return super.computeRippleBoundingRect();\r\n        const {left, top} = this._elm.nativeElement.getBoundingClientRect();\r\n        return {\r\n            left,\r\n            top,\r\n            width: this._dim,\r\n            height: this._dim,\r\n            right: left + this._dim,\r\n            bottom: top + this._dim,\r\n        };\r\n    }\r\n\r\n    /**\r\n     * Set this input to false to remove the ripple effect from the surface.\r\n     */\r\n    @Input() get mdcRipple() {\r\n        return this._on;\r\n    }\r\n\r\n    set mdcRipple(value: boolean) {\r\n        const newValue = asBoolean(value);\r\n        if (newValue !== this._on) {\r\n            this._on = newValue;\r\n            if (this._initialized) {\r\n                if (newValue)\r\n                    this.initRipple();\r\n                else\r\n                    this.destroyRipple();\r\n            }\r\n        }\r\n    }\r\n\r\n    static ngAcceptInputType_mdcRipple: boolean | '';\r\n\r\n    /**\r\n     * When this input has a value other than false, the ripple is unbounded.\r\n     * Surfaces for bounded ripples should have <code>overflow</code> set to hidden,\r\n     * while surfaces for unbounded ripples should have it set to <code>visible</code>.\r\n     */\r\n    @Input() get unbounded() {\r\n        return this.isRippleUnbounded();\r\n    }\r\n\r\n    set unbounded(value: boolean) {\r\n        this.setRippleUnbounded(asBoolean(value));\r\n    }\r\n\r\n    static ngAcceptInputType_unbounded: boolean | '';\r\n\r\n    /** @internal */\r\n    @HostBinding('attr.data-mdc-ripple-is-unbounded') get _attrUnbounded() {\r\n        return this.unbounded ? \"\" : null;\r\n    }\r\n\r\n    /**\r\n     * This input sets the dimension of the ripple.\r\n     * This input can be set to null for returning to the defaults, which uses the surface\r\n     * element to compute the bounds of the ripple.\r\n     */\r\n    @Input() get dimension() {\r\n        return this._dim;\r\n    }\r\n\r\n    set dimension(value: number | null) {\r\n        this._dim = value == null ? null : +value;\r\n        this.layout();\r\n    }\r\n\r\n    static ngAcceptInputType_dimension: string | number | null;\r\n\r\n    /**\r\n     * This input can be used to programmatically enable/disable the ripple.\r\n     * When true, the ripple effect will be disabled, when false the ripple\r\n     * effect will be enabled. When not set, or <code>null</code> (default)\r\n     * the ripple effect enabled/disabled state depend on whether or not the\r\n     * surface element has the <code>disabled</code> attribute set.\r\n     */\r\n    @Input() get disabled() {\r\n        return this._disabled;\r\n    }\r\n\r\n    set disabled(value: boolean | null) {\r\n        this._disabled = asBooleanOrNull(value);\r\n    }\r\n\r\n    static ngAcceptInputType_boolean: boolean | null | '';\r\n\r\n    /**\r\n     * When this input has a value other than false, the ripple element will get the\r\n     * \"mdc-ripple-surface\" class. That class has styling for bounded and unbounded\r\n     * ripples in accordance with your theme customizations. Without this property,\r\n     * you have to supply your own ripple styles, using the provided\r\n     * <a href=\"https://github.com/material-components/material-components-web/tree/master/packages/mdc-ripple#sass-apis\"\r\n     *   target=\"_blank\">Sass Mixins</a>.\r\n     * \r\n     * To apply a standard surface ripple, set the value to `true`, `\"primary\"`, or `\"accent\"`.\r\n     * The values primary and accent set the ripple color to the theme primary or secondary color.\r\n     */\r\n    @Input() @HostBinding('class.mdc-ripple-surface') get surface() {\r\n        return !!this._surface;\r\n    }\r\n\r\n    set surface(value: boolean | 'primary' | 'accent') {\r\n        if (value === 'primary' || value === 'accent')\r\n            this._surface = value;\r\n        else\r\n            this._surface = asBoolean(value);\r\n    }\r\n\r\n    static ngAcceptInputType_surface: boolean | 'primary' | 'accent' | '';\r\n\r\n    @HostBinding('class.mdc-ripple-surface--primary') get _surfacePrimary() {\r\n        return this._surface === 'primary';\r\n    }\r\n\r\n    @HostBinding('class.mdc-ripple-surface--accent') get _surfaceAccent() {\r\n        return this._surface === 'accent';\r\n    }\r\n}\r\n"]}