ngx-mat-lib/esm5/lib/directives/xmat-badge/xmat-badge.directive.js

A bunch of utilities and components to use in your Angular 7+ apps!

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
 */
import { AriaDescriber } from "@angular/cdk/a11y";
import { coerceBooleanProperty } from "@angular/cdk/coercion";
import { Directive, ElementRef, Input, NgZone, Renderer2 } from "@angular/core";
/** @typedef {?} */
var XmatBadgePosition;
export { XmatBadgePosition };
/** @typedef {?} */
var XmatBadgeSize;
export { XmatBadgeSize };
/**
 * Directive to display a text badge.
 */
var XmatBadgeDirective = /** @class */ (function () {
    function XmatBadgeDirective(_ngZone, _ariaDescriber, _renderer, elementRef) {
        this._ngZone = _ngZone;
        this._ariaDescriber = _ariaDescriber;
        this._renderer = _renderer;
        /*
             * Size of the badge. Can be "small", "medium", or "large".
             */
        // tslint:disable-next-line:no-input-rename
        this.size = "medium";
        /*
             * Position the badge should reside.
             * Accepts any combination of "above"|"below" and "before"|"after"
             */
        // tslint:disable-next-line:no-input-rename
        this.position = "below after";
        /**
         * Whether the badge has any content.
         */
        this.hasContent = false;
        /**
         * Unique id for the badge
         */
        this.id = XmatBadgeDirective.nextId++;
        this._color = "primary";
        this._overlap = true;
        // Bridge to the new Angular6 typed ElementRef
        this._elementRef = new ElementRef(elementRef.nativeElement);
    }
    Object.defineProperty(XmatBadgeDirective.prototype, "color", {
        get: /**
         * @return {?}
         */
        function () {
            return this._color;
        },
        /** The color of the badge. Can be `primary`, `accent`, or `warn`. */
        set: /**
         * The color of the badge. Can be `primary`, `accent`, or `warn`.
         * @param {?} value
         * @return {?}
         */
        function (value) {
            this._setColor(value);
            this._color = value;
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(XmatBadgeDirective.prototype, "overlap", {
        /** Whether the badge should overlap its contents or not */
        get: /**
         * Whether the badge should overlap its contents or not
         * @return {?}
         */
        function () {
            return this._overlap;
        },
        set: /**
         * @param {?} val
         * @return {?}
         */
        function (val) {
            this._overlap = coerceBooleanProperty(val);
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(XmatBadgeDirective.prototype, "content", {
        get: /**
         * @return {?}
         */
        function () {
            return this._content;
        },
        /** The content for the badge */
        set: /**
         * The content for the badge
         * @param {?} value
         * @return {?}
         */
        function (value) {
            this._content = value;
            this.hasContent = value != null && ("" + value).trim().length > 0;
            this._updateTextContent();
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(XmatBadgeDirective.prototype, "description", {
        get: /**
         * @return {?}
         */
        function () {
            return this._description;
        },
        /** Message used to describe the decorated element via aria-describedby */
        set: /**
         * Message used to describe the decorated element via aria-describedby
         * @param {?} newDescription
         * @return {?}
         */
        function (newDescription) {
            if (newDescription !== this._description) {
                this._updateHostAriaDescription(newDescription, this._description);
                this._description = newDescription;
            }
        },
        enumerable: true,
        configurable: true
    });
    Object.defineProperty(XmatBadgeDirective.prototype, "hidden", {
        /** Whether the badge is hidden. */
        get: /**
         * Whether the badge is hidden.
         * @return {?}
         */
        function () {
            return this._hidden;
        },
        set: /**
         * @param {?} val
         * @return {?}
         */
        function (val) {
            this._hidden = coerceBooleanProperty(val);
        },
        enumerable: true,
        configurable: true
    });
    /** Whether the badge is above the host or not */
    /**
     * Whether the badge is above the host or not
     * @return {?}
     */
    XmatBadgeDirective.prototype.isAbove = /**
     * Whether the badge is above the host or not
     * @return {?}
     */
    function () {
        return this.position.indexOf("below") === -1;
    };
    /** Whether the badge is after the host or not */
    /**
     * Whether the badge is after the host or not
     * @return {?}
     */
    XmatBadgeDirective.prototype.isAfter = /**
     * Whether the badge is after the host or not
     * @return {?}
     */
    function () {
        return this.position.indexOf("before") === -1;
    };
    /**
     * @return {?}
     */
    XmatBadgeDirective.prototype.ngOnDestroy = /**
     * @return {?}
     */
    function () {
        if (this.description && this._badgeElement) {
            this._ariaDescriber.removeDescription(this._badgeElement, this.description);
        }
    };
    /**
     * Injects a span element into the DOM with the content.
     * @return {?}
     */
    XmatBadgeDirective.prototype._updateTextContent = /**
     * Injects a span element into the DOM with the content.
     * @return {?}
     */
    function () {
        if (!this._badgeElement) {
            this._badgeElement = this._createBadgeElement();
        }
        else {
            this._badgeElement.textContent = this.content;
        }
        return this._badgeElement;
    };
    /**
     * Creates the badge element
     * @return {?}
     */
    XmatBadgeDirective.prototype._createBadgeElement = /**
     * Creates the badge element
     * @return {?}
     */
    function () {
        /** @type {?} */
        var rootNode = this._renderer;
        /** @type {?} */
        var badgeElement = document.createElement("span");
        /** @type {?} */
        var activeClass = "xmat-badge-active";
        badgeElement.setAttribute("id", "xmat-badge-content-" + this.id);
        badgeElement.classList.add("xmat-badge-content");
        badgeElement.textContent = this.content;
        if (this.description) {
            badgeElement.setAttribute("aria-label", this.description);
        }
        this._elementRef.nativeElement.appendChild(badgeElement);
        // animate in after insertion
        if (typeof requestAnimationFrame === "function") {
            this._ngZone.runOutsideAngular(function () {
                requestAnimationFrame(function () {
                    badgeElement.classList.add(activeClass);
                });
            });
        }
        else {
            badgeElement.classList.add(activeClass);
        }
        return badgeElement;
    };
    /**
     * Adds css theme class given the color to the component host
     * @param {?} colorPalette
     * @return {?}
     */
    XmatBadgeDirective.prototype._setColor = /**
     * Adds css theme class given the color to the component host
     * @param {?} colorPalette
     * @return {?}
     */
    function (colorPalette) {
        if (colorPalette !== this._color) {
            if (this._color) {
                this._elementRef.nativeElement.classList.remove("xmat-badge-" + this._color);
            }
            if (colorPalette) {
                this._elementRef.nativeElement.classList.add("xmat-badge-" + colorPalette);
            }
        }
    };
    /**
     * Sets the aria-label property on the element
     * @param {?} newDescription
     * @param {?} oldDescription
     * @return {?}
     */
    XmatBadgeDirective.prototype._updateHostAriaDescription = /**
     * Sets the aria-label property on the element
     * @param {?} newDescription
     * @param {?} oldDescription
     * @return {?}
     */
    function (newDescription, oldDescription) {
        /** @type {?} */
        var content = this._updateTextContent();
        if (oldDescription) {
            this._ariaDescriber.removeDescription(content, oldDescription);
        }
        if (newDescription) {
            this._ariaDescriber.describe(content, newDescription);
        }
    };
    XmatBadgeDirective.nextId = 0;
    XmatBadgeDirective.decorators = [
        { type: Directive, args: [{
                    selector: "[xmatBadge]",
                    host: {
                        "class": "xmat-badge",
                        "[class.xmat-badge-overlap]": "overlap",
                        "[class.xmat-badge-above]": "isAbove()",
                        "[class.xmat-badge-below]": "!isAbove()",
                        "[class.xmat-badge-before]": "!isAfter()",
                        "[class.xmat-badge-after]": "isAfter()",
                        "[class.xmat-badge-small]": "size === 'small'",
                        "[class.xmat-badge-medium]": "size === 'medium'",
                        "[class.xmat-badge-large]": "size === 'large'",
                        "[class.xmat-badge-hidden]": "hidden || !hasContent",
                    },
                },] }
    ];
    /** @nocollapse */
    XmatBadgeDirective.ctorParameters = function () { return [
        { type: NgZone },
        { type: AriaDescriber },
        { type: Renderer2 },
        { type: ElementRef }
    ]; };
    XmatBadgeDirective.propDecorators = {
        size: [{ type: Input, args: ["xmatBadgeSize",] }],
        position: [{ type: Input, args: ["xmatBadgePosition",] }],
        color: [{ type: Input, args: ["xmatBadgeColor",] }],
        overlap: [{ type: Input, args: ["xmatBadgeOverlap",] }],
        content: [{ type: Input, args: ["xmatBadge",] }],
        description: [{ type: Input, args: ["xmatBadgeDescription",] }],
        hidden: [{ type: Input, args: ["xmatBadgeHidden",] }]
    };
    return XmatBadgeDirective;
}());
export { XmatBadgeDirective };
if (false) {
    /** @type {?} */
    XmatBadgeDirective.nextId;
    /** @type {?} */
    XmatBadgeDirective.prototype.size;
    /** @type {?} */
    XmatBadgeDirective.prototype.position;
    /**
     * Whether the badge has any content.
     * @type {?}
     */
    XmatBadgeDirective.prototype.hasContent;
    /**
     * Unique id for the badge
     * @type {?}
     */
    XmatBadgeDirective.prototype.id;
    /** @type {?} */
    XmatBadgeDirective.prototype._badgeElement;
    /** @type {?} */
    XmatBadgeDirective.prototype._color;
    /** @type {?} */
    XmatBadgeDirective.prototype._content;
    /** @type {?} */
    XmatBadgeDirective.prototype._description;
    /** @type {?} */
    XmatBadgeDirective.prototype._elementRef;
    /** @type {?} */
    XmatBadgeDirective.prototype._hidden;
    /** @type {?} */
    XmatBadgeDirective.prototype._overlap;
    /** @type {?} */
    XmatBadgeDirective.prototype._ngZone;
    /** @type {?} */
    XmatBadgeDirective.prototype._ariaDescriber;
    /** @type {?} */
    XmatBadgeDirective.prototype._renderer;
}

//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"xmat-badge.directive.js","sourceRoot":"ng://ngx-mat-lib/","sources":["lib/directives/xmat-badge/xmat-badge.directive.ts"],"names":[],"mappings":";;;;AAAA,OAAO,EAAC,aAAa,EAAC,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAC,qBAAqB,EAAC,MAAM,uBAAuB,CAAC;AAC5D,OAAO,EACH,SAAS,EAAE,UAAU,EACrB,KAAK,EACL,MAAM,EAEN,SAAS,EACZ,MAAM,eAAe,CAAC;;;;;;;;;;;IA6GnB,4BAAoB,OAAe,EACf,gBACA,WACR,UAAsB;QAHd,YAAO,GAAP,OAAO,CAAQ;QACf,mBAAc,GAAd,cAAc;QACd,cAAS,GAAT,SAAS;;;;;QAjF7B,YAA8C,QAAQ,CAAC;;;;;;QAOvD,gBAA0D,aAAa,CAAC;;;;QA2DxE,kBAAa,KAAK,CAAC;;;;QAEnB,UAAa,kBAAkB,CAAC,MAAM,EAAE,CAAC;sBAGV,SAAS;wBAKZ,IAAI;;QAS5B,IAAI,CAAC,WAAW,GAAG,IAAI,UAAU,CAAc,UAAU,CAAC,aAAa,CAAC,CAAC;KAC5E;IA5ED,sBACI,qCAAK;;;;QAKT;YACI,OAAO,IAAI,CAAC,MAAM,CAAC;SACtB;QATD,qEAAqE;;;;;;QACrE,UACU,KAAmB;YACzB,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;YACtB,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;SACvB;;;OAAA;IAOD,sBACI,uCAAO;QAFX,2DAA2D;;;;;QAC3D;YAEI,OAAO,IAAI,CAAC,QAAQ,CAAC;SACxB;;;;;QAED,UAAY,GAAY;YACpB,IAAI,CAAC,QAAQ,GAAG,qBAAqB,CAAC,GAAG,CAAC,CAAC;SAC9C;;;OAJA;IAOD,sBACI,uCAAO;;;;QAMX;YACI,OAAO,IAAI,CAAC,QAAQ,CAAC;SACxB;QAVD,gCAAgC;;;;;;QAChC,UACY,KAAa;YACrB,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC;YACtB,IAAI,CAAC,UAAU,GAAG,KAAK,IAAI,IAAI,IAAI,CAAA,KAAG,KAAO,CAAA,CAAC,IAAI,EAAE,CAAC,MAAM,GAAG,CAAC,CAAC;YAChE,IAAI,CAAC,kBAAkB,EAAE,CAAC;SAC7B;;;OAAA;IAOD,sBACI,2CAAW;;;;QAOf;YACI,OAAO,IAAI,CAAC,YAAY,CAAC;SAC5B;QAXD,0EAA0E;;;;;;QAC1E,UACgB,cAAsB;YAClC,IAAI,cAAc,KAAK,IAAI,CAAC,YAAY,EAAE;gBACtC,IAAI,CAAC,0BAA0B,CAAC,cAAc,EAAE,IAAI,CAAC,YAAY,CAAC,CAAC;gBACnE,IAAI,CAAC,YAAY,GAAG,cAAc,CAAC;aACtC;SACJ;;;OAAA;IAOD,sBACI,sCAAM;QAFV,mCAAmC;;;;;QACnC;YAEI,OAAO,IAAI,CAAC,OAAO,CAAC;SACvB;;;;;QAED,UAAW,GAAY;YACnB,IAAI,CAAC,OAAO,GAAG,qBAAqB,CAAC,GAAG,CAAC,CAAC;SAC7C;;;OAJA;IA6BD,iDAAiD;;;;;IACjD,oCAAO;;;;IAAP;QACI,OAAO,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC;KAChD;IAED,iDAAiD;;;;;IACjD,oCAAO;;;;IAAP;QACI,OAAO,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC;KACjD;;;;IAED,wCAAW;;;IAAX;QACI,IAAI,IAAI,CAAC,WAAW,IAAI,IAAI,CAAC,aAAa,EAAE;YACxC,IAAI,CAAC,cAAc,CAAC,iBAAiB,CAAC,IAAI,CAAC,aAAa,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC;SAC/E;KACJ;;;;;IAGO,+CAAkB;;;;;QACtB,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE;YACrB,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,mBAAmB,EAAE,CAAC;SACnD;aAAM;YACH,IAAI,CAAC,aAAa,CAAC,WAAW,GAAG,IAAI,CAAC,OAAO,CAAC;SACjD;QACD,OAAO,IAAI,CAAC,aAAa,CAAC;;;;;;IAItB,gDAAmB;;;;;;QACvB,IAAM,QAAQ,GAAG,IAAI,CAAC,SAAS,CAAC;;QAChC,IAAM,YAAY,GAAG,QAAQ,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC;;QACpD,IAAM,WAAW,GAAG,mBAAmB,CAAC;QAExC,YAAY,CAAC,YAAY,CAAC,IAAI,EAAE,wBAAsB,IAAI,CAAC,EAAI,CAAC,CAAC;QACjE,YAAY,CAAC,SAAS,CAAC,GAAG,CAAC,oBAAoB,CAAC,CAAC;QACjD,YAAY,CAAC,WAAW,GAAG,IAAI,CAAC,OAAO,CAAC;QAExC,IAAI,IAAI,CAAC,WAAW,EAAE;YAClB,YAAY,CAAC,YAAY,CAAC,YAAY,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC;SAC7D;QAED,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,WAAW,CAAC,YAAY,CAAC,CAAC;;QAGzD,IAAI,OAAO,qBAAqB,KAAK,UAAU,EAAE;YAC7C,IAAI,CAAC,OAAO,CAAC,iBAAiB,CAAC;gBAC3B,qBAAqB,CAAC;oBAClB,YAAY,CAAC,SAAS,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;iBAC3C,CAAC,CAAC;aACN,CAAC,CAAC;SACN;aAAM;YACH,YAAY,CAAC,SAAS,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;SAC3C;QAED,OAAO,YAAY,CAAC;;;;;;;IAIhB,sCAAS;;;;;cAAC,YAA0B;QACxC,IAAI,YAAY,KAAK,IAAI,CAAC,MAAM,EAAE;YAC9B,IAAI,IAAI,CAAC,MAAM,EAAE;gBACb,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,SAAS,CAAC,MAAM,CAAC,gBAAc,IAAI,CAAC,MAAQ,CAAC,CAAC;aAChF;YACD,IAAI,YAAY,EAAE;gBACd,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,SAAS,CAAC,GAAG,CAAC,gBAAc,YAAc,CAAC,CAAC;aAC9E;SACJ;;;;;;;;IAIG,uDAA0B;;;;;;cAAC,cAAsB,EAAE,cAAsB;;QAE7E,IAAM,OAAO,GAAG,IAAI,CAAC,kBAAkB,EAAE,CAAC;QAE1C,IAAI,cAAc,EAAE;YAChB,IAAI,CAAC,cAAc,CAAC,iBAAiB,CAAC,OAAO,EAAE,cAAc,CAAC,CAAC;SAClE;QAED,IAAI,cAAc,EAAE;YAChB,IAAI,CAAC,cAAc,CAAC,QAAQ,CAAC,OAAO,EAAE,cAAc,CAAC,CAAC;SACzD;;IA7KL,4BAAwB,CAAC,CAAC;;gBAjB7B,SAAS,SAAC;oBACP,QAAQ,EAAE,aAAa;oBACvB,IAAI,EAAE;wBACF,OAAO,EAAE,YAAY;wBACrB,4BAA4B,EAAE,SAAS;wBACvC,0BAA0B,EAAE,WAAW;wBACvC,0BAA0B,EAAE,YAAY;wBACxC,2BAA2B,EAAE,YAAY;wBACzC,0BAA0B,EAAE,WAAW;wBACvC,0BAA0B,EAAE,kBAAkB;wBAC9C,2BAA2B,EAAE,mBAAmB;wBAChD,0BAA0B,EAAE,kBAAkB;wBAC9C,2BAA2B,EAAE,uBAAuB;qBACvD;iBACJ;;;;gBAxBG,MAAM;gBALF,aAAa;gBAOjB,SAAS;gBAJE,UAAU;;;uBAmCpB,KAAK,SAAC,eAAe;2BAOrB,KAAK,SAAC,mBAAmB;wBAGzB,KAAK,SAAC,gBAAgB;0BAWtB,KAAK,SAAC,kBAAkB;0BAUxB,KAAK,SAAC,WAAW;8BAYjB,KAAK,SAAC,sBAAsB;yBAa5B,KAAK,SAAC,iBAAiB;;6BA9F5B;;SA8Ba,kBAAkB","sourcesContent":["import {AriaDescriber} from \"@angular/cdk/a11y\";\nimport {coerceBooleanProperty} from \"@angular/cdk/coercion\";\nimport {\n    Directive, ElementRef,\n    Input,\n    NgZone,\n    OnDestroy,\n    Renderer2\n} from \"@angular/core\";\nimport {ThemePalette} from \"@angular/material/core\";\n\nexport type XmatBadgePosition = \"above after\" | \"above before\" | \"below before\" | \"below after\";\nexport type XmatBadgeSize = \"small\" | \"medium\" | \"large\";\n\n/** Directive to display a text badge. */\n@Directive({\n    selector: \"[xmatBadge]\",\n    host: {\n        \"class\": \"xmat-badge\",\n        \"[class.xmat-badge-overlap]\": \"overlap\",\n        \"[class.xmat-badge-above]\": \"isAbove()\",\n        \"[class.xmat-badge-below]\": \"!isAbove()\",\n        \"[class.xmat-badge-before]\": \"!isAfter()\",\n        \"[class.xmat-badge-after]\": \"isAfter()\",\n        \"[class.xmat-badge-small]\": \"size === 'small'\",\n        \"[class.xmat-badge-medium]\": \"size === 'medium'\",\n        \"[class.xmat-badge-large]\": \"size === 'large'\",\n        \"[class.xmat-badge-hidden]\": \"hidden || !hasContent\",\n    },\n})\nexport class XmatBadgeDirective implements OnDestroy {\n\n    static nextId: number = 0;\n\n    /*\n     * Size of the badge. Can be \"small\", \"medium\", or \"large\".\n     */\n    // tslint:disable-next-line:no-input-rename\n    @Input(\"xmatBadgeSize\") size: XmatBadgeSize = \"medium\";\n\n    /*\n     * Position the badge should reside.\n     * Accepts any combination of \"above\"|\"below\" and \"before\"|\"after\"\n     */\n    // tslint:disable-next-line:no-input-rename\n    @Input(\"xmatBadgePosition\") position: XmatBadgePosition = \"below after\";\n\n    /** The color of the badge. Can be `primary`, `accent`, or `warn`. */\n    @Input(\"xmatBadgeColor\")\n    set color(value: ThemePalette) {\n        this._setColor(value);\n        this._color = value;\n    }\n\n    get color(): ThemePalette {\n        return this._color;\n    }\n\n    /** Whether the badge should overlap its contents or not */\n    @Input(\"xmatBadgeOverlap\")\n    get overlap(): boolean {\n        return this._overlap;\n    }\n\n    set overlap(val: boolean) {\n        this._overlap = coerceBooleanProperty(val);\n    }\n\n    /** The content for the badge */\n    @Input(\"xmatBadge\")\n    set content(value: string) {\n        this._content = value;\n        this.hasContent = value != null && `${value}`.trim().length > 0;\n        this._updateTextContent();\n    }\n\n    get content(): string {\n        return this._content;\n    }\n\n    /** Message used to describe the decorated element via aria-describedby */\n    @Input(\"xmatBadgeDescription\")\n    set description(newDescription: string) {\n        if (newDescription !== this._description) {\n            this._updateHostAriaDescription(newDescription, this._description);\n            this._description = newDescription;\n        }\n    }\n\n    get description(): string {\n        return this._description;\n    }\n\n    /** Whether the badge is hidden. */\n    @Input(\"xmatBadgeHidden\")\n    get hidden(): boolean {\n        return this._hidden;\n    }\n\n    set hidden(val: boolean) {\n        this._hidden = coerceBooleanProperty(val);\n    }\n\n    /** Whether the badge has any content. */\n    hasContent = false;\n    /** Unique id for the badge */\n    id: number = XmatBadgeDirective.nextId++;\n\n    private _badgeElement: HTMLElement;\n    private _color: ThemePalette = \"primary\";\n    private _content: string;\n    private _description: string;\n    private _elementRef: ElementRef<HTMLElement>;\n    private _hidden: boolean;\n    private _overlap: boolean = true;\n\n\n    constructor(private _ngZone: NgZone,\n                private _ariaDescriber: AriaDescriber,\n                private _renderer: Renderer2,\n                elementRef: ElementRef) {\n\n        // Bridge to the new Angular6 typed ElementRef\n        this._elementRef = new ElementRef<HTMLElement>(elementRef.nativeElement);\n    }\n\n    /** Whether the badge is above the host or not */\n    isAbove(): boolean {\n        return this.position.indexOf(\"below\") === -1;\n    }\n\n    /** Whether the badge is after the host or not */\n    isAfter(): boolean {\n        return this.position.indexOf(\"before\") === -1;\n    }\n\n    ngOnDestroy() {\n        if (this.description && this._badgeElement) {\n            this._ariaDescriber.removeDescription(this._badgeElement, this.description);\n        }\n    }\n\n    /** Injects a span element into the DOM with the content. */\n    private _updateTextContent(): HTMLSpanElement {\n        if (!this._badgeElement) {\n            this._badgeElement = this._createBadgeElement();\n        } else {\n            this._badgeElement.textContent = this.content;\n        }\n        return this._badgeElement;\n    }\n\n    /** Creates the badge element */\n    private _createBadgeElement(): HTMLElement {\n        const rootNode = this._renderer;\n        const badgeElement = document.createElement(\"span\");\n        const activeClass = \"xmat-badge-active\";\n\n        badgeElement.setAttribute(\"id\", `xmat-badge-content-${this.id}`);\n        badgeElement.classList.add(\"xmat-badge-content\");\n        badgeElement.textContent = this.content;\n\n        if (this.description) {\n            badgeElement.setAttribute(\"aria-label\", this.description);\n        }\n\n        this._elementRef.nativeElement.appendChild(badgeElement);\n\n        // animate in after insertion\n        if (typeof requestAnimationFrame === \"function\") {\n            this._ngZone.runOutsideAngular(() => {\n                requestAnimationFrame(() => {\n                    badgeElement.classList.add(activeClass);\n                });\n            });\n        } else {\n            badgeElement.classList.add(activeClass);\n        }\n\n        return badgeElement;\n    }\n\n    /** Adds css theme class given the color to the component host */\n    private _setColor(colorPalette: ThemePalette) {\n        if (colorPalette !== this._color) {\n            if (this._color) {\n                this._elementRef.nativeElement.classList.remove(`xmat-badge-${this._color}`);\n            }\n            if (colorPalette) {\n                this._elementRef.nativeElement.classList.add(`xmat-badge-${colorPalette}`);\n            }\n        }\n    }\n\n    /** Sets the aria-label property on the element */\n    private _updateHostAriaDescription(newDescription: string, oldDescription: string): void {\n        // ensure content available before setting label\n        const content = this._updateTextContent();\n\n        if (oldDescription) {\n            this._ariaDescriber.removeDescription(content, oldDescription);\n        }\n\n        if (newDescription) {\n            this._ariaDescriber.describe(content, newDescription);\n        }\n    }\n\n}\n"]}