@blox/material
Version:
Material Components for Angular
250 lines • 24.6 kB
JavaScript
import { ContentChildren, Directive, ElementRef, HostBinding, Inject, Input, Renderer2 } from '@angular/core';
import { DOCUMENT } from '@angular/common';
import { asBoolean } from '../../utils/value.utils';
import { AbstractMdcIcon } from '../icon-button/abstract.mdc.icon';
import { MdcButtonDirective } from '../button/mdc.button.directive';
import { AbstractMdcRipple } from '../ripple/abstract.mdc.ripple';
import { MdcEventRegistry } from '../../utils/mdc.event.registry';
/**
* Directive for an area that displays a custom background-image. See the <code>size</code>
* property for the sizing of the image.
* If used, this directive should be put inside the card itself (<code>MdcCardDirective</code>).
* Add an <code>mdcCardMediaContent</code> as sub-element for displaying a title, text,
* or icon on top of the background image.
*/
export class MdcCardMediaDirective {
constructor() {
/** @internal */
this._cls = true;
this._size = 'cover';
}
/** @internal */
get _square() {
return this._size === 'square';
}
/** @internal */
get _size2() {
return this._size === '16:9';
}
/**
* Directive to select size to which this element's background-image should
* be scaled. Can be one of 'cover', '16:9', or 'square'. The default value
* is 'cover'.
*/
get size() {
return this._size;
}
set size(val) {
this._size = val;
}
}
MdcCardMediaDirective.decorators = [
{ type: Directive, args: [{
selector: '[mdcCardMedia]',
},] }
];
MdcCardMediaDirective.ctorParameters = () => [];
MdcCardMediaDirective.propDecorators = {
_cls: [{ type: HostBinding, args: ['class.mdc-card__media',] }],
_square: [{ type: HostBinding, args: ['class.mdc-card__media--square',] }],
_size2: [{ type: HostBinding, args: ['class.mdc-card__media--16-9',] }],
size: [{ type: Input }]
};
/**
* Directive for displaying text on top of a <code>mdcCardMedia</code> element.
* This directive should be used as child element of the <code>mdcCardMedia</code>, and
* creates an absolutely positioned box the same size as the media area.
*/
export class MdcCardMediaContentDirective {
constructor() {
/** @internal */
this._cls = true;
}
}
MdcCardMediaContentDirective.decorators = [
{ type: Directive, args: [{
selector: '[mdcCardMediaContent]'
},] }
];
MdcCardMediaContentDirective.propDecorators = {
_cls: [{ type: HostBinding, args: ['class.mdc-card__media-content',] }]
};
/**
* Directive for displaying the button card actions. Composed of one or more
* card actions, which must be buttons that have the <code>MdcButtonDirective</code>.
* This directive should be placed inside an <code>MdcCardActionsDirective</code>.
*/
export class MdcCardActionButtonsDirective {
constructor() {
/** @internal */
this._cls = true;
}
}
MdcCardActionButtonsDirective.decorators = [
{ type: Directive, args: [{
selector: '[mdcCardActionButtons]'
},] }
];
MdcCardActionButtonsDirective.propDecorators = {
_cls: [{ type: HostBinding, args: ['class.mdc-card__action-buttons',] }]
};
/**
* Directive for displaying the icon card actions. Composed of one or more
* card actions, which must be icons (for instance <code>mdcIconButton</code>.
* This directive should be placed inside an <code>MdcCardActionsDirective</code>.
*/
export class MdcCardActionIconsDirective {
constructor() {
/** @internal */
this._cls = true;
}
}
MdcCardActionIconsDirective.decorators = [
{ type: Directive, args: [{
selector: '[mdcCardActionIcons]'
},] }
];
MdcCardActionIconsDirective.propDecorators = {
_cls: [{ type: HostBinding, args: ['class.mdc-card__action-icons',] }]
};
/**
* Directive for showing the different actions a user can take. Use
* <code>mdcButton</code>, or <code>mdcIconButton</code> as child elements.
* If you want to use both buttons and icons in the same row, wrap them in
* <code>mdcCardActionButtons</code>, and <code>mdcCardActionIcons</code> directives.
*/
export class MdcCardActionsDirective {
constructor(renderer) {
this.renderer = renderer;
/** @internal */
this._cls = true;
this._initialized = false;
this._fullBleed = false;
}
ngAfterContentInit() {
this._initialized = true;
this._initButtons();
this._initIcons();
this._buttons.changes.subscribe(() => {
this._initButtons();
});
this._icons.changes.subscribe(() => {
this._initIcons();
});
}
_initButtons() {
if (this._initialized)
this._buttons.forEach(btn => {
this.renderer.addClass(btn._elm.nativeElement, 'mdc-card__action');
this.renderer.addClass(btn._elm.nativeElement, 'mdc-card__action--button');
});
}
_initIcons() {
if (this._initialized)
this._icons.forEach(icon => {
this.renderer.addClass(icon._elm.nativeElement, 'mdc-card__action');
this.renderer.addClass(icon._elm.nativeElement, 'mdc-card__action--icon');
});
}
/**
* When this input is defined and does not have value false, the contained
* button takes up the entire width of the action row. This should be used only when
* there is a single button contained in the directive.
*/
get fullBleed() {
return this._fullBleed;
}
set fullBleed(val) {
this._fullBleed = asBoolean(val);
}
}
MdcCardActionsDirective.decorators = [
{ type: Directive, args: [{
selector: '[mdcCardActions]',
},] }
];
MdcCardActionsDirective.ctorParameters = () => [
{ type: Renderer2 }
];
MdcCardActionsDirective.propDecorators = {
_cls: [{ type: HostBinding, args: ['class.mdc-card__actions',] }],
_buttons: [{ type: ContentChildren, args: [MdcButtonDirective, { descendants: true },] }],
_icons: [{ type: ContentChildren, args: [AbstractMdcIcon, { descendants: true },] }],
fullBleed: [{ type: HostBinding, args: ['class.mdc-card__actions--full-bleed',] }, { type: Input }]
};
/**
* Directive for the main tappable area of the card (so should be a child of <code>mdcCard</code>).
* Typically contains most (or all) card content except <code>mdcCardActions</code>.
* Only applicable to cards that have a primary action that the main surface should trigger.
*/
export class MdcCardPrimaryActionDirective extends AbstractMdcRipple {
constructor(elm, renderer, registry, doc) {
super(elm, renderer, registry, doc);
this.elm = elm;
/** @internal */
this._cls = true;
}
ngAfterContentInit() {
if (!this.elm.nativeElement.hasAttribute('tabindex'))
// unless overridden, make the action tabbable:
this.elm.nativeElement.tabIndex = 0;
this.initRipple();
}
ngOnDestroy() {
this.destroyRipple();
}
}
MdcCardPrimaryActionDirective.decorators = [
{ type: Directive, args: [{
selector: '[mdcCardPrimaryAction]',
},] }
];
MdcCardPrimaryActionDirective.ctorParameters = () => [
{ type: ElementRef },
{ type: Renderer2 },
{ type: MdcEventRegistry },
{ type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] }
];
MdcCardPrimaryActionDirective.propDecorators = {
_cls: [{ type: HostBinding, args: ['class.mdc-card__primary-action',] }]
};
/**
* Directive for a material designed card. The card can be composed with the following directives:
* <code>MdcCardMediaDirective</code>, <code>MdcCardActionsDirective</code>
*/
export class MdcCardDirective {
constructor() {
/** @internal */
this._cls = true;
this._outlined = false;
}
/**
* When this input is set to a value other than false, the card will have a
* hairline stroke instead of a shadow.
*/
get outlined() {
return this._outlined;
}
set outlined(val) {
this._outlined = asBoolean(val);
}
}
MdcCardDirective.decorators = [
{ type: Directive, args: [{
selector: '[mdcCard]'
},] }
];
MdcCardDirective.propDecorators = {
_cls: [{ type: HostBinding, args: ['class.mdc-card',] }],
outlined: [{ type: HostBinding, args: ['class.mdc-card--outlined',] }, { type: Input }]
};
export const CARD_DIRECTIVES = [
MdcCardMediaDirective,
MdcCardMediaContentDirective,
MdcCardActionButtonsDirective,
MdcCardActionIconsDirective,
MdcCardActionsDirective,
MdcCardPrimaryActionDirective,
MdcCardDirective
];
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"mdc.card.directive.js","sourceRoot":"","sources":["../../../../src/components/card/mdc.card.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { AfterContentInit, ContentChildren, Directive, ElementRef, HostBinding, Inject, Input, OnDestroy,\n    QueryList, Renderer2 } from '@angular/core';\nimport { DOCUMENT } from '@angular/common';\nimport { asBoolean } from '../../utils/value.utils';\nimport { AbstractMdcIcon } from '../icon-button/abstract.mdc.icon';\nimport { MdcButtonDirective } from '../button/mdc.button.directive';\nimport { AbstractMdcRipple } from '../ripple/abstract.mdc.ripple';\nimport { MdcEventRegistry } from '../../utils/mdc.event.registry';\n\n/**\n * Directive for an area that displays a custom background-image. See the <code>size</code>\n * property for the sizing of the image.\n * If used, this directive should be put inside the card itself (<code>MdcCardDirective</code>).\n * Add an <code>mdcCardMediaContent</code> as sub-element for displaying a title, text,\n * or icon on top of the background image. \n */\n@Directive({\n    selector: '[mdcCardMedia]',\n})\nexport class MdcCardMediaDirective {\n    /** @internal */\n    @HostBinding('class.mdc-card__media') readonly _cls = true;\n    private _size: 'cover' | '16:9' | 'square' = 'cover';\n        \n    constructor() {}\n\n    /** @internal */\n    @HostBinding('class.mdc-card__media--square') get _square() {\n        return this._size === 'square';\n    }\n\n    /** @internal */\n    @HostBinding('class.mdc-card__media--16-9') get _size2() {\n        return this._size === '16:9';\n    }\n\n    /**\n     * Directive to select size to which this element's background-image should\n     * be scaled. Can be one of 'cover', '16:9', or 'square'. The default value\n     * is 'cover'.\n     */\n    @Input() get size(): 'cover' | '16:9' | 'square' {\n        return this._size;\n    }\n    \n    set size(val: 'cover' | '16:9' | 'square') {\n        this._size = val;\n    }\n}\n\n/**\n * Directive for displaying text on top of a <code>mdcCardMedia</code> element.\n * This directive should be used as child element of the <code>mdcCardMedia</code>, and\n * creates an absolutely positioned box the same size as the media area.\n */\n@Directive({\n    selector: '[mdcCardMediaContent]'\n})\nexport class MdcCardMediaContentDirective {\n    /** @internal */\n    @HostBinding('class.mdc-card__media-content') readonly _cls = true;\n}\n\n/**\n * Directive for displaying the button card actions. Composed of one or more\n * card actions, which must be buttons that have the <code>MdcButtonDirective</code>.\n * This directive should be placed inside an <code>MdcCardActionsDirective</code>.\n */\n@Directive({\n    selector: '[mdcCardActionButtons]'\n})\nexport class MdcCardActionButtonsDirective {\n    /** @internal */\n    @HostBinding('class.mdc-card__action-buttons') readonly _cls = true;\n}\n\n/**\n * Directive for displaying the icon card actions. Composed of one or more\n * card actions, which must be icons (for instance <code>mdcIconButton</code>.\n * This directive should be placed inside an <code>MdcCardActionsDirective</code>.\n */\n@Directive({\n    selector: '[mdcCardActionIcons]'\n})\nexport class MdcCardActionIconsDirective {\n    /** @internal */\n    @HostBinding('class.mdc-card__action-icons') readonly _cls = true;\n}\n\n/**\n * Directive for showing the different actions a user can take. Use\n * <code>mdcButton</code>, or <code>mdcIconButton</code> as child elements.\n * If you want to use both buttons and icons in the same row, wrap them in\n * <code>mdcCardActionButtons</code>, and <code>mdcCardActionIcons</code> directives.\n */\n@Directive({\n    selector: '[mdcCardActions]',\n})\nexport class MdcCardActionsDirective implements AfterContentInit {\n    /** @internal */\n    @HostBinding('class.mdc-card__actions') readonly _cls = true;\n    /** @internal */\n    @ContentChildren(MdcButtonDirective, {descendants: true}) _buttons?: QueryList<MdcButtonDirective>;\n    /** @internal */\n    @ContentChildren(AbstractMdcIcon, {descendants: true}) _icons?: QueryList<AbstractMdcIcon>;\n    private _initialized = false;\n    private _fullBleed = false;\n\n    constructor(private renderer: Renderer2) {}\n\n    ngAfterContentInit() {\n        this._initialized = true;\n        this._initButtons();\n        this._initIcons();\n        this._buttons!.changes.subscribe(() => {\n            this._initButtons();\n        });\n        this._icons!.changes.subscribe(() => {\n            this._initIcons();\n        })\n    }\n\n    private _initButtons() {\n        if (this._initialized)\n            this._buttons!.forEach(btn => {\n                this.renderer.addClass(btn._elm.nativeElement, 'mdc-card__action');\n                this.renderer.addClass(btn._elm.nativeElement, 'mdc-card__action--button');\n            });\n    }\n\n    private _initIcons() {\n        if (this._initialized)\n            this._icons!.forEach(icon => {\n                this.renderer.addClass(icon._elm.nativeElement, 'mdc-card__action');\n                this.renderer.addClass(icon._elm.nativeElement, 'mdc-card__action--icon');\n            });\n    }\n\n    /**\n     * When this input is defined and does not have value false, the contained\n     * button takes up the entire width of the action row. This should be used only when\n     * there is a single button contained in the directive.\n     */\n    @HostBinding('class.mdc-card__actions--full-bleed') @Input()\n    get fullBleed() {\n        return this._fullBleed;\n    }\n\n    set fullBleed(val: boolean) {\n        this._fullBleed = asBoolean(val);\n    }\n\n    static ngAcceptInputType_fullBleed: boolean | '';\n}\n\n/**\n * Directive for the main tappable area of the card (so should be a child of <code>mdcCard</code>).\n * Typically contains most (or all) card content except <code>mdcCardActions</code>.\n * Only applicable to cards that have a primary action that the main surface should trigger.\n */\n@Directive({\n    selector: '[mdcCardPrimaryAction]',\n})\nexport class MdcCardPrimaryActionDirective extends AbstractMdcRipple implements AfterContentInit, OnDestroy {\n    /** @internal */\n    @HostBinding('class.mdc-card__primary-action') readonly _cls = true;\n\n    constructor(private elm: ElementRef, renderer: Renderer2, registry: MdcEventRegistry, @Inject(DOCUMENT) doc: any) {\n        super(elm, renderer, registry, doc as Document);\n    }\n\n    ngAfterContentInit() {\n        if (!this.elm.nativeElement.hasAttribute('tabindex'))\n            // unless overridden, make the action tabbable:\n            this.elm.nativeElement.tabIndex = 0;\n        this.initRipple();\n    }\n  \n    ngOnDestroy() {\n        this.destroyRipple();\n    }\n}\n\n/**\n * Directive for a material designed card. The card can be composed with the following directives:\n * <code>MdcCardMediaDirective</code>, <code>MdcCardActionsDirective</code>\n */\n@Directive({\n    selector: '[mdcCard]'\n})\nexport class MdcCardDirective {\n    /** @internal */\n    @HostBinding('class.mdc-card') readonly _cls = true;\n    private _outlined = false;\n\n    /**\n     * When this input is set to a value other than false, the card will have a\n     * hairline stroke instead of a shadow.\n     */\n    @HostBinding('class.mdc-card--outlined') @Input()\n    get outlined() {\n        return this._outlined;\n    }\n\n    set outlined(val: boolean) {\n        this._outlined = asBoolean(val);\n    }\n\n    static ngAcceptInputType_outlined: boolean | '';\n}\n\nexport const CARD_DIRECTIVES = [\n    MdcCardMediaDirective,\n    MdcCardMediaContentDirective,\n    MdcCardActionButtonsDirective,\n    MdcCardActionIconsDirective,\n    MdcCardActionsDirective,\n    MdcCardPrimaryActionDirective,\n    MdcCardDirective\n];"]}