mgx-circular-progress-bar/bundles/mgx-circular-progress-bar.umd.js

A library for circular progress bars components, an elegant way to rappresent your percentages.

(function (global, factory) {
    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/core'), require('@angular/common')) :
    typeof define === 'function' && define.amd ? define('mgx-circular-progress-bar', ['exports', '@angular/core', '@angular/common'], factory) :
    (factory((global['mgx-circular-progress-bar'] = {}),global.ng.core,global.ng.common));
}(this, (function (exports,core,common) { 'use strict';

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
     */
    var MgxCircularProgressFullBarComponent = (function () {
        function MgxCircularProgressFullBarComponent() {
            this.total = 1;
            this.barValue = 0;
            this.percentage = 0;
            this.diameter = 150;
            this.color = '#3282b8';
            this.bgColor = '#eee';
            this.contentSize = 83;
            this.pathPosition = 90;
            this.mgxPrefix = 'mgx-circular-progress-full-bar';
            this.percentual = 0;
            this.context = { percentual: 0, $implicit: 0 };
        }
        /**
         * @return {?}
         */
        MgxCircularProgressFullBarComponent.prototype.ngOnChanges = /**
         * @return {?}
         */
            function () {
                /** @type {?} */
                var circle = this.circlePath.nativeElement;
                /** @type {?} */
                var len = 2 * Math.PI * this.pathPosition;
                circle.style.strokeDasharray = len;
                this.showWarnings();
                this.percentual = +this.percentage || (+this.barValue / +this.total) * 100;
                this.percentual = isNaN(this.percentual) ? 0 : +this.percentual.toFixed(2);
                if (this.percentual > 100) {
                    circle.style.strokeDashoffset = 0;
                    this.percentual = 100;
                }
                else {
                    circle.style.strokeDashoffset = len - (this.percentual / 100) * len;
                }
                this.context.percentual = this.percentual;
                this.context.$implicit = this.percentual;
            };
        /**
         * @return {?}
         */
        MgxCircularProgressFullBarComponent.prototype.showWarnings = /**
         * @return {?}
         */
            function () {
                if (!this.percentual || isNaN(this.percentual)) {
                    if (isNaN(this.barValue)) {
                        console.warn(this.mgxPrefix + " barValue: " + this.barValue);
                    }
                    else if (isNaN(this.total)) {
                        console.warn(this.mgxPrefix + " total: " + this.total);
                    }
                    else if (this.barValue > this.total) {
                        console.warn(this.mgxPrefix + " barValue: " + this.barValue + " is more than total: " + this.total);
                    }
                }
            };
        /**
         * @param {?=} reducer
         * @return {?}
         */
        MgxCircularProgressFullBarComponent.prototype.getFontSize = /**
         * @param {?=} reducer
         * @return {?}
         */
            function (reducer) {
                if (reducer === void 0) {
                    reducer = 1;
                }
                return (this.fontSize || (this.diameter / 4)) / reducer + "px";
            };
        MgxCircularProgressFullBarComponent.decorators = [
            { type: core.Component, args: [{
                        selector: 'mgx-circular-progress-full-bar',
                        template: "<div class=\"contain\">\n    <svg xmlns=\"http://www.w3.org/2000/svg\" x=\"0\" y=\"0\" [ngStyle]=\"{'width.px': diameter, 'height.px': diameter }\"\n        viewBox=\"0 0 200 200\">\n        <circle id=\"base-circle\" [attr.fill]=\"bgColor\" stroke-width=\"15\" cx=\"100\" cy=\"100\" [attr.r]=\"contentSize\" />\n        <circle id=\"path\" #circlePath [attr.stroke]=\"color\" fill=\"none\" stroke-width=\"15\" cx=\"100\" cy=\"100\"\n            [attr.r]=\"pathPosition\" rotate=\"50\" />\n    </svg>\n    <div class=\"label\">\n        <ng-container *ngIf=\"contentTemplate; else projectContent\">\n            <ng-template *ngTemplateOutlet=\"contentTemplate; context: context\"></ng-template>\n        </ng-container>\n        <ng-template #projectContent>\n            <div #contentRef>\n                <ng-content></ng-content>\n            </div>\n            <div *ngIf=\"!contentRef?.childNodes?.length\" [style.font-size]=\"getFontSize()\">{{percentual}}<span\n                    [style.font-size]=\"getFontSize(1.2)\">&#37;</span></div>\n        </ng-template>\n    </div>\n</div>",
                        styles: [".contain{display:-webkit-box;display:flex;-webkit-box-pack:center;justify-content:center;-webkit-box-align:center;align-items:center;-webkit-box-orient:vertical;-webkit-box-direction:normal;flex-direction:column;box-sizing:border-box;position:relative}#path{transform:rotate(-90deg);-webkit-transform:rotate(-90deg);-ms-transform:rotate(-90deg);-moz-transform:rotate(-90deg);transform-origin:center center;-webkit-transform-origin:center center;-ms-transform-origin:center center;-moz-transform-origin:center center;transition:stroke-dashoffset .3s ease-in-out;-webkit-transition:stroke-dashoffset .3s ease-in-out;-ms-transition:stroke-dashoffset .3s ease-in-out;-moz-transition:stroke-dashoffset .3s ease-in-out}#pie-path{transform:rotate(-90deg);-webkit-transform:rotate(-90deg);-ms-transform:rotate(-90deg);-moz-transform:rotate(-90deg)}.label{position:absolute;top:0;right:0;bottom:0;left:0;display:-webkit-box;display:flex;flex-wrap:wrap;-webkit-box-pack:center;justify-content:center;-webkit-box-align:center;align-items:center;font-family:Kreon VariableFont;color:#7f8c8d}"]
                    },] },
        ];
        /** @nocollapse */
        MgxCircularProgressFullBarComponent.ctorParameters = function () { return []; };
        MgxCircularProgressFullBarComponent.propDecorators = {
            total: [{ type: core.Input }],
            barValue: [{ type: core.Input }],
            percentage: [{ type: core.Input }],
            contentTemplate: [{ type: core.Input }],
            diameter: [{ type: core.Input }],
            fontSize: [{ type: core.Input }],
            color: [{ type: core.Input }],
            bgColor: [{ type: core.Input }],
            contentSize: [{ type: core.Input }],
            pathPosition: [{ type: core.Input }],
            circlePath: [{ type: core.ViewChild, args: ['circlePath',] }]
        };
        return MgxCircularProgressFullBarComponent;
    }());

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
     */
    var MgxCircularProgressFullBarModule = (function () {
        function MgxCircularProgressFullBarModule() {
        }
        MgxCircularProgressFullBarModule.decorators = [
            { type: core.NgModule, args: [{
                        imports: [common.CommonModule],
                        declarations: [MgxCircularProgressFullBarComponent],
                        exports: [MgxCircularProgressFullBarComponent]
                    },] },
        ];
        return MgxCircularProgressFullBarModule;
    }());

    /*! *****************************************************************************
    Copyright (c) Microsoft Corporation. All rights reserved.
    Licensed under the Apache License, Version 2.0 (the "License"); you may not use
    this file except in compliance with the License. You may obtain a copy of the
    License at http://www.apache.org/licenses/LICENSE-2.0

    THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
    KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
    WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
    MERCHANTABLITY OR NON-INFRINGEMENT.

    See the Apache Version 2.0 License for specific language governing permissions
    and limitations under the License.
    ***************************************************************************** */
    function __read(o, n) {
        var m = typeof Symbol === "function" && o[Symbol.iterator];
        if (!m)
            return o;
        var i = m.call(o), r, ar = [], e;
        try {
            while ((n === void 0 || n-- > 0) && !(r = i.next()).done)
                ar.push(r.value);
        }
        catch (error) {
            e = { error: error };
        }
        finally {
            try {
                if (r && !r.done && (m = i["return"]))
                    m.call(i);
            }
            finally {
                if (e)
                    throw e.error;
            }
        }
        return ar;
    }

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
     */
    var MgxCircularProgressPieComponent = (function () {
        function MgxCircularProgressPieComponent() {
            /* Data section */
            this.total = 1;
            this.barValue = 0;
            this.percentage = 0;
            this.diameter = 150;
            this.color = '#3282b8';
            this.bgColor = '#eee';
            this.bgSize = 10;
            this.mgxPrefix = 'mgx-circular-progress-pie';
            this.percentual = 0;
        }
        /**
         * @return {?}
         */
        MgxCircularProgressPieComponent.prototype.ngOnChanges = /**
         * @return {?}
         */
            function () {
                this.showWarnings();
                this.percentual = +this.percentage || (+this.barValue / +this.total) * 100;
                this.percentual = isNaN(this.percentual) ? 0 : +this.percentual.toFixed(2);
                if (this.percentual > 100) {
                    this.setSlice(1);
                    this.percentual = 100;
                }
                else {
                    this.setSlice(this.percentual / 100);
                }
            };
        /**
         * @param {?} percent
         * @return {?}
         */
        MgxCircularProgressPieComponent.prototype.setSlice = /**
         * @param {?} percent
         * @return {?}
         */
            function (percent) {
                var _a = __read(this.getCoordinatesForPercent(percent), 2), endX = _a[0], endY = _a[1];
                /** @type {?} */
                var largeArcFlag = percent > .5 ? 1 : 0;
                this.pathData = [
                    "M 1 0",
                    "A 1 1 0 " + largeArcFlag + " 1 " + endX + " " + endY,
                    "L 0 0",
                ].join(' ');
            };
        /**
         * @param {?} percent
         * @return {?}
         */
        MgxCircularProgressPieComponent.prototype.getCoordinatesForPercent = /**
         * @param {?} percent
         * @return {?}
         */
            function (percent) {
                /** @type {?} */
                var x = Math.cos(2 * Math.PI * percent);
                /** @type {?} */
                var y = Math.sin(2 * Math.PI * percent);
                return [x, y];
            };
        /**
         * @return {?}
         */
        MgxCircularProgressPieComponent.prototype.showWarnings = /**
         * @return {?}
         */
            function () {
                if (!this.percentage || isNaN(this.percentage)) {
                    if (isNaN(this.barValue)) {
                        console.warn(this.mgxPrefix + " barValue: " + this.barValue);
                    }
                    else if (isNaN(this.total)) {
                        console.warn(this.mgxPrefix + " total: " + this.total);
                    }
                    else if (this.barValue > this.total) {
                        console.warn(this.mgxPrefix + " barValue: " + this.barValue + " is more than total: " + this.total);
                    }
                }
            };
        /**
         * @param {?=} reducer
         * @return {?}
         */
        MgxCircularProgressPieComponent.prototype.getFontSize = /**
         * @param {?=} reducer
         * @return {?}
         */
            function (reducer) {
                if (reducer === void 0) {
                    reducer = 1;
                }
                return (this.fontSize || (this.diameter / 4)) / reducer + "px";
            };
        MgxCircularProgressPieComponent.decorators = [
            { type: core.Component, args: [{
                        selector: 'mgx-circular-progress-pie',
                        template: "<div class=\"contain\">\n    <svg xmlns=\"http://www.w3.org/2000/svg\" x=\"0\" y=\"0\" [ngStyle]=\"{'width.px': diameter, 'height.px': diameter }\"\n        viewBox=\"-1 -1 2 2\">\n        <circle id=\"base-circle\" [attr.stroke]=\"bgColor\" [attr.fill]=\"bgColor\" cx=\"0\" cy=\"0\" [attr.r]=\"bgSize / 20\" />\n        <path id=\"pie-path\" [attr.fill]=\"color\" [attr.d]=\"pathData\" rotate=\"50\"></path>\n    </svg>\n    <div class=\"label\">\n        <ng-container *ngIf=\"contentTemplate; else projectContent\">\n            <ng-template *ngTemplateOutlet=\"contentTemplate\"></ng-template>\n        </ng-container>\n        <ng-template #projectContent>\n            <div #contentRef>\n                <ng-content></ng-content>\n            </div>\n            <div *ngIf=\"!contentRef?.childNodes?.length\" [style.font-size]=\"getFontSize()\">\n                {{percentual}}<span [style.font-size]=\"getFontSize(1.2)\">&#37;</span>\n            </div>\n        </ng-template>\n    </div>\n</div>",
                        styles: [".contain{display:-webkit-box;display:flex;-webkit-box-pack:center;justify-content:center;-webkit-box-align:center;align-items:center;-webkit-box-orient:vertical;-webkit-box-direction:normal;flex-direction:column;box-sizing:border-box;position:relative}#path{transform:rotate(-90deg);-webkit-transform:rotate(-90deg);-ms-transform:rotate(-90deg);-moz-transform:rotate(-90deg);transform-origin:center center;-webkit-transform-origin:center center;-ms-transform-origin:center center;-moz-transform-origin:center center;transition:stroke-dashoffset .3s ease-in-out;-webkit-transition:stroke-dashoffset .3s ease-in-out;-ms-transition:stroke-dashoffset .3s ease-in-out;-moz-transition:stroke-dashoffset .3s ease-in-out}#pie-path{transform:rotate(-90deg);-webkit-transform:rotate(-90deg);-ms-transform:rotate(-90deg);-moz-transform:rotate(-90deg)}.label{position:absolute;top:0;right:0;bottom:0;left:0;display:-webkit-box;display:flex;flex-wrap:wrap;-webkit-box-pack:center;justify-content:center;-webkit-box-align:center;align-items:center;font-family:Kreon VariableFont;color:#7f8c8d}"]
                    },] },
        ];
        /** @nocollapse */
        MgxCircularProgressPieComponent.ctorParameters = function () { return []; };
        MgxCircularProgressPieComponent.propDecorators = {
            total: [{ type: core.Input }],
            barValue: [{ type: core.Input }],
            percentage: [{ type: core.Input }],
            contentTemplate: [{ type: core.Input }],
            diameter: [{ type: core.Input }],
            fontSize: [{ type: core.Input }],
            color: [{ type: core.Input }],
            bgColor: [{ type: core.Input }],
            bgSize: [{ type: core.Input }]
        };
        return MgxCircularProgressPieComponent;
    }());

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
     */
    var MgxCircularProgressPieModule = (function () {
        function MgxCircularProgressPieModule() {
        }
        MgxCircularProgressPieModule.decorators = [
            { type: core.NgModule, args: [{
                        imports: [common.CommonModule],
                        declarations: [MgxCircularProgressPieComponent],
                        exports: [MgxCircularProgressPieComponent]
                    },] },
        ];
        return MgxCircularProgressPieModule;
    }());

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
     */
    var MgxCircularProgressBarComponent = (function () {
        function MgxCircularProgressBarComponent() {
            /* Data section */
            this.total = 1;
            this.barValue = 0;
            this.percentage = 0;
            this.diameter = 150;
            this.color = '#3282b8';
            this.bgColor = '#eee';
            this.radius = 90;
            this.mgxPrefix = 'mgx-circular-progress-bar';
            this.percentual = 0;
            this.context = { percentual: 0, $implicit: 0 };
        }
        /**
         * @return {?}
         */
        MgxCircularProgressBarComponent.prototype.ngOnChanges = /**
         * @return {?}
         */
            function () {
                /** @type {?} */
                var circle = this.circlePath.nativeElement;
                /** @type {?} */
                var len = 2 * Math.PI * this.radius;
                circle.style.strokeDasharray = len;
                this.showWarnings();
                this.percentual = +this.percentage || (+this.barValue / +this.total) * 100;
                this.percentual = isNaN(this.percentual) ? 0 : +this.percentual.toFixed(2);
                if (this.percentual > 100) {
                    circle.style.strokeDashoffset = 0;
                    this.percentual = 100;
                }
                else {
                    circle.style.strokeDashoffset = len - (this.percentual / 100) * len;
                }
                this.context.percentual = this.percentual;
                this.context.$implicit = this.percentual;
            };
        /**
         * @return {?}
         */
        MgxCircularProgressBarComponent.prototype.showWarnings = /**
         * @return {?}
         */
            function () {
                if (!this.percentage || isNaN(this.percentage)) {
                    if (isNaN(this.barValue)) {
                        console.warn(this.mgxPrefix + " barValue: " + this.barValue);
                    }
                    else if (isNaN(this.total)) {
                        console.warn(this.mgxPrefix + " total: " + this.total);
                    }
                    else if (this.barValue > this.total) {
                        console.warn(this.mgxPrefix + " barValue: " + this.barValue + " is more than total: " + this.total);
                    }
                }
            };
        /**
         * @param {?=} reducer
         * @return {?}
         */
        MgxCircularProgressBarComponent.prototype.getFontSize = /**
         * @param {?=} reducer
         * @return {?}
         */
            function (reducer) {
                if (reducer === void 0) {
                    reducer = 1;
                }
                return (this.fontSize || (this.diameter / 4)) / reducer + "px";
            };
        MgxCircularProgressBarComponent.decorators = [
            { type: core.Component, args: [{
                        selector: 'mgx-circular-progress-bar',
                        template: "\n  <div class=\"contain\">\n    <svg  xmlns=\"http://www.w3.org/2000/svg\" x=\"0\" y=\"0\" [ngStyle]=\"{'width.px': diameter, 'height.px': diameter }\" viewBox=\"0 0 200 200\">\n        <circle id=\"base-circle\" [attr.stroke]=\"bgColor\" fill=\"none\" stroke-width=\"15\" cx=\"100\" cy=\"100\"\n            [attr.r]=\"radius\" />\n        <circle id=\"path\" #circlePath [attr.stroke]=\"color\" fill=\"none\" stroke-width=\"15\" cx=\"100\" cy=\"100\"\n            [attr.r]=\"radius\" rotate=\"50\" />\n    </svg>\n    <div class=\"label\">\n        <ng-container *ngIf=\"contentTemplate; else projectContent\">\n            <ng-template *ngTemplateOutlet=\"contentTemplate; context: context\"></ng-template>\n        </ng-container>\n        <ng-template #projectContent>\n            <div #contentRef>\n                <ng-content></ng-content>\n            </div>\n            <div *ngIf=\"!contentRef?.childNodes?.length\" [style.font-size]=\"getFontSize()\">\n                {{percentual}}<span [style.font-size]=\"getFontSize(1.2)\">&#37;</span>\n            </div>\n        </ng-template>\n    </div>\n</div>",
                        styles: [".contain{display:-webkit-box;display:flex;-webkit-box-pack:center;justify-content:center;-webkit-box-align:center;align-items:center;-webkit-box-orient:vertical;-webkit-box-direction:normal;flex-direction:column;box-sizing:border-box;position:relative}#path{transform:rotate(-90deg);-webkit-transform:rotate(-90deg);-ms-transform:rotate(-90deg);-moz-transform:rotate(-90deg);transform-origin:center center;-webkit-transform-origin:center center;-ms-transform-origin:center center;-moz-transform-origin:center center;transition:stroke-dashoffset .3s ease-in-out;-webkit-transition:stroke-dashoffset .3s ease-in-out;-ms-transition:stroke-dashoffset .3s ease-in-out;-moz-transition:stroke-dashoffset .3s ease-in-out}#pie-path{transform:rotate(-90deg);-webkit-transform:rotate(-90deg);-ms-transform:rotate(-90deg);-moz-transform:rotate(-90deg)}.label{position:absolute;top:0;right:0;bottom:0;left:0;display:-webkit-box;display:flex;flex-wrap:wrap;-webkit-box-pack:center;justify-content:center;-webkit-box-align:center;align-items:center;font-family:Kreon VariableFont;color:#7f8c8d}"]
                    },] },
        ];
        /** @nocollapse */
        MgxCircularProgressBarComponent.ctorParameters = function () { return []; };
        MgxCircularProgressBarComponent.propDecorators = {
            total: [{ type: core.Input }],
            barValue: [{ type: core.Input }],
            percentage: [{ type: core.Input }],
            contentTemplate: [{ type: core.Input }],
            diameter: [{ type: core.Input }],
            fontSize: [{ type: core.Input }],
            color: [{ type: core.Input }],
            bgColor: [{ type: core.Input }],
            circlePath: [{ type: core.ViewChild, args: ['circlePath',] }]
        };
        return MgxCircularProgressBarComponent;
    }());

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
     */
    var MgxCircularProgressBarModule = (function () {
        function MgxCircularProgressBarModule() {
        }
        MgxCircularProgressBarModule.decorators = [
            { type: core.NgModule, args: [{
                        imports: [common.CommonModule],
                        declarations: [MgxCircularProgressBarComponent],
                        exports: [MgxCircularProgressBarComponent]
                    },] },
        ];
        return MgxCircularProgressBarModule;
    }());

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
     */
    var MgxCircularProgressModule = (function () {
        function MgxCircularProgressModule() {
        }
        MgxCircularProgressModule.decorators = [
            { type: core.NgModule, args: [{
                        imports: [
                            common.CommonModule,
                            MgxCircularProgressBarModule,
                            MgxCircularProgressPieModule,
                            MgxCircularProgressFullBarModule
                        ],
                        exports: [
                            MgxCircularProgressBarModule,
                            MgxCircularProgressPieModule,
                            MgxCircularProgressFullBarModule
                        ]
                    },] },
        ];
        return MgxCircularProgressModule;
    }());

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
     */

    /**
     * @fileoverview added by tsickle
     * @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
     */

    exports.MgxCircularProgressModule = MgxCircularProgressModule;
    exports.MgxCircularProgressBarModule = MgxCircularProgressBarModule;
    exports.MgxCircularProgressFullBarModule = MgxCircularProgressFullBarModule;
    exports.MgxCircularProgressPieModule = MgxCircularProgressPieModule;
    exports.ɵa = MgxCircularProgressBarComponent;
    exports.ɵc = MgxCircularProgressFullBarComponent;
    exports.ɵb = MgxCircularProgressPieComponent;

    Object.defineProperty(exports, '__esModule', { value: true });

})));

//# sourceMappingURL=data:application/json;charset=utf-8;base64,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