cf-common-lib/fesm2015/cf-common-lib.js

Object Validators and Utilities

import { Injectable, ɵɵdefineInjectable, Component, NgModule, ɵstringify, Pipe, ChangeDetectorRef, NgZone } from '@angular/core';

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
class CfUtilityService {
    constructor() { }
}
CfUtilityService.decorators = [
    { type: Injectable, args: [{
                providedIn: 'root'
            },] }
];
/** @nocollapse */
CfUtilityService.ctorParameters = () => [];
/** @nocollapse */ CfUtilityService.ngInjectableDef = ɵɵdefineInjectable({ factory: function CfUtilityService_Factory() { return new CfUtilityService(); }, token: CfUtilityService, providedIn: "root" });

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
class CfUtilityComponent {
    constructor() { }
    /**
     * @return {?}
     */
    ngOnInit() {
    }
}
CfUtilityComponent.decorators = [
    { type: Component, args: [{
                selector: 'lib-cf-utility',
                template: `
    <p>
      cf-utility works!
    </p>
  `
            }] }
];
/** @nocollapse */
CfUtilityComponent.ctorParameters = () => [];

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
class CfUtilityModule {
}
CfUtilityModule.decorators = [
    { type: NgModule, args: [{
                declarations: [CfUtilityComponent],
                imports: [],
                exports: [CfUtilityComponent]
            },] }
];

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
class PropagatorUtilService {
    constructor() { }
    /**
     * @param {?} objects
     * @param {?} keyName
     * @param {?} value
     * @param {?} ignoreCase
     * @return {?}
     */
    findInObjectsArrayFromKey(objects, keyName, value, ignoreCase) {
        if (ignoreCase) {
            return objects.find((/**
             * @param {?} item
             * @return {?}
             */
            item => {
                return item[keyName].toLowerCase() == value.toLowerCase();
            }));
        }
        return objects.find((/**
         * @param {?} item
         * @return {?}
         */
        item => {
            return item[keyName] == value;
        }));
    }
    ;
    /**
     * @param {?} objects
     * @param {?} keyName
     * @return {?}
     */
    extractKeysFromObjectsList(objects, keyName) {
        return objects.map((/**
         * @param {?} item
         * @return {?}
         */
        item => {
            return item[keyName];
        }));
    }
    ;
    /**
     * @param {?} objects
     * @param {?} key
     * @param {?} value
     * @return {?}
     */
    objectArrayIndexOf(objects, key, value) {
        return this.extractKeysFromObjectsList(objects, key).indexOf(value);
    }
    ;
    /**
     * @param {?} objects
     * @param {?} key
     * @param {?} value
     * @return {?}
     */
    objectArrayFindFromKey(objects, key, value) {
        /** @type {?} */
        let index = this.extractKeysFromObjectsList(objects, key).indexOf(value);
        if (index === -1) {
            return;
        }
        return objects[index];
    }
    ;
    /**
     * @param {?} objects
     * @param {?} keyName
     * @param {?} value
     * @return {?}
     */
    filterInObjectsArrayFromKey(objects, keyName, value) {
        return objects.filter((/**
         * @param {?} item
         * @return {?}
         */
        item => {
            return item[keyName] === value;
        }));
    }
    ;
    /**
     * @param {?} objects
     * @param {?} keys
     * @param {?} keyName
     * @return {?}
     */
    filterObjectsFromKeys(objects, keys, keyName) {
        return objects.filter((/**
         * @param {?} item
         * @return {?}
         */
        item => {
            return keys.indexOf(item[keyName]) !== -1;
        }));
    }
    ;
    /**
     * @param {?} _arr
     * @return {?}
     */
    flattenArray(_arr) {
        return _flattenArray(_arr);
        /**
         * @param {?} _arr
         * @return {?}
         */
        function _flattenArray(_arr) {
            return _arr.reduce((/**
             * @param {?} _acc
             * @param {?} _value
             * @return {?}
             */
            function (_acc, _value) {
                return Array.isArray(_value)
                    ? _acc.concat(_flattenArray(_value))
                    : _acc.concat(_value);
            }), []);
        }
    }
    /**
     * @param {?} callback
     * @param {...?} urls
     * @return {?}
     */
    jsCssScriptInjector(callback, ...urls) {
        /** @type {?} */
        let _count = 0;
        /** @type {?} */
        let _element;
        this.flattenArray(urls).forEach((/**
         * @param {?} _url
         * @return {?}
         */
        _url => {
            if (_url.endsWith(".js")) {
                _element = document.createElement('script');
                _element.src = _url;
                _element.type = 'text/javascript';
                _element.async = true;
            }
            if (_url.endsWith(".css")) {
                _element = document.createElement('link');
                _element.rel = "stylesheet";
                _element.href = _url;
            }
            if (callback) {
                _element.addEventListener("load", (/**
                 * @return {?}
                 */
                function () {
                    _count++;
                    if (_count == urls.length) {
                        callback(urls);
                    }
                }));
            }
            document.getElementsByTagName('head')[0].appendChild(_element);
        }));
    }
    /**
     * @param {?} x
     * @param {?} y
     * @return {?}
     */
    isObjectsEqual(x, y) {
        return _objectEquals(x, y);
        /**
         * @param {?} x
         * @param {?} y
         * @return {?}
         */
        function _objectEquals(x, y) {
            if (x === null || x === undefined || y === null || y === undefined) {
                return x === y;
            }
            // after this just checking type of one would be enough
            if (x.constructor !== y.constructor) {
                return false;
            }
            // if they are functions, they should exactly refer to same one (because of closures)
            if (x instanceof Function) {
                return x === y;
            }
            // if they are regexps, they should exactly refer to same one (it is hard to better equality check on current ES)
            if (x instanceof RegExp) {
                return x === y;
            }
            if (x === y || x.valueOf() === y.valueOf()) {
                return true;
            }
            if (Array.isArray(x) && x.length !== y.length) {
                return false;
            }
            // if they are dates, they must had equal valueOf
            if (x instanceof Date) {
                return false;
            }
            // if they are strictly equal, they both need to be object at least
            if (!(x instanceof Object)) {
                return false;
            }
            if (!(y instanceof Object)) {
                return false;
            }
            // recursive object equality check
            /** @type {?} */
            var p = Object.keys(x);
            return Object.keys(y).every((/**
             * @param {?} i
             * @return {?}
             */
            function (i) { return p.indexOf(i) !== -1; })) &&
                p.every((/**
                 * @param {?} i
                 * @return {?}
                 */
                function (i) { return _objectEquals(x[i], y[i]); }));
        }
    }
    /**
     * @param {?} _exclude
     * @param {?} _list
     * @return {?}
     */
    excludeValuesFromObjectList(_exclude, _list) {
        return _excludeValuesFromObjectList(_exclude, _list);
        /**
         * @param {?} _exclude
         * @param {?} _list
         * @return {?}
         */
        function _excludeValuesFromObjectList(_exclude, _list) {
            /** @type {?} */
            let temp = [];
            for (var _ex in _exclude) {
                _exclude[_ex].forEach((/**
                 * @param {?} _item
                 * @return {?}
                 */
                function (_item) {
                    temp = _list.filter((/**
                     * @param {?} book
                     * @return {?}
                     */
                    function (book) {
                        return book[_ex] != _item;
                    }));
                    _list = temp;
                }));
            }
            return _list;
        }
    }
}
PropagatorUtilService.decorators = [
    { type: Injectable, args: [{
                providedIn: 'root'
            },] }
];
/** @nocollapse */
PropagatorUtilService.ctorParameters = () => [];
/** @nocollapse */ PropagatorUtilService.ngInjectableDef = ɵɵdefineInjectable({ factory: function PropagatorUtilService_Factory() { return new PropagatorUtilService(); }, token: PropagatorUtilService, providedIn: "root" });

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
/** @type {?} */
const pincodeRegx = new RegExp('^[1-9][0-9]{5}$');
/** @type {?} */
const panRegx = new RegExp('^([a-zA-Z]){5}([0-9]){4}([a-zA-Z]){1}?$');
/** @type {?} */
const gstinRegx = new RegExp('^[0-9]{2}[A-Z]{5}[0-9]{4}[A-Z]{1}[1-9A-Z]{1}Z[0-9A-Z]{1}$');
class ValidatorService {
    constructor() { }
    /**
     * @param {?} _value
     * @return {?}
     */
    removeSpace(_value) {
        _value ? _value.replace(/\s/g, '') : '';
        return _value;
    }
    /**
     * @param {?} _value
     * @return {?}
     */
    pincodeCheck(_value) {
        return pincodeRegx.test(this.removeSpace(_value));
    }
    /**
     * @param {?} _value
     * @return {?}
     */
    panCheck(_value) {
        return panRegx.test(this.removeSpace(_value));
    }
    /**
     * @param {?} _value
     * @return {?}
     */
    gstinCheck(_value) {
        return gstinRegx.test(this.removeSpace(_value));
    }
    /**
     * @param {?} _aadhaar
     * @return {?}
     */
    aadhaarCheck(_aadhaar) {
        /** @type {?} */
        let Verhoeff = {
            "d": [
                [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
                [1, 2, 3, 4, 0, 6, 7, 8, 9, 5],
                [2, 3, 4, 0, 1, 7, 8, 9, 5, 6],
                [3, 4, 0, 1, 2, 8, 9, 5, 6, 7],
                [4, 0, 1, 2, 3, 9, 5, 6, 7, 8],
                [5, 9, 8, 7, 6, 0, 4, 3, 2, 1],
                [6, 5, 9, 8, 7, 1, 0, 4, 3, 2],
                [7, 6, 5, 9, 8, 2, 1, 0, 4, 3],
                [8, 7, 6, 5, 9, 3, 2, 1, 0, 4],
                [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
            ],
            "p": [
                [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
                [1, 5, 7, 6, 2, 8, 3, 0, 9, 4],
                [5, 8, 0, 3, 7, 9, 6, 1, 4, 2],
                [8, 9, 1, 6, 0, 4, 3, 5, 2, 7],
                [9, 4, 5, 3, 1, 2, 6, 8, 7, 0],
                [4, 2, 8, 6, 5, 7, 3, 9, 0, 1],
                [2, 7, 9, 3, 8, 0, 6, 4, 1, 5],
                [7, 0, 4, 6, 9, 1, 3, 2, 5, 8]
            ],
            "j": [0, 4, 3, 2, 1, 5, 6, 7, 8, 9],
            check: (/**
             * @param {?} str
             * @return {?}
             */
            (str) => {
                /** @type {?} */
                var c = 0;
                str.replace(/\D+/g, "").split("").reverse().join("").replace(/[\d]/g, (/**
                 * @param {?} u
                 * @param {?} i
                 * @param {?} o
                 * @return {?}
                 */
                (u, i, o) => {
                    c = Verhoeff.d[c][Verhoeff.p[i & 7][parseInt(u, 10)]];
                }));
                return (c === 0);
            })
        };
        return Verhoeff.check(_aadhaar);
    }
}
ValidatorService.decorators = [
    { type: Injectable, args: [{
                providedIn: 'root'
            },] }
];
/** @nocollapse */
ValidatorService.ctorParameters = () => [];
/** @nocollapse */ ValidatorService.ngInjectableDef = ɵɵdefineInjectable({ factory: function ValidatorService_Factory() { return new ValidatorService(); }, token: ValidatorService, providedIn: "root" });

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
class DeviceDetectorService {
    constructor() { }
    /**
     * @return {?}
     */
    _knowYourBrowser() {
        if ((navigator.userAgent.indexOf("Opera") || navigator.userAgent.indexOf('OPR')) != -1) {
            return 'Opera';
        }
        else if (navigator.userAgent.indexOf("Chrome") != -1) {
            return 'Chrome';
        }
        else if (navigator.userAgent.indexOf("Safari") != -1) {
            return 'Safari';
        }
        else if (navigator.userAgent.indexOf("Firefox") != -1) {
            return 'Firefox';
        }
        else if ((navigator.userAgent.indexOf("MSIE") != -1) || (!!window.document.documentMode == true)) //IF IE > 10
         {
            return 'IE';
        }
        else {
            return 'Unknown';
        }
    }
    /**
     * @return {?}
     */
    info() {
        return {
            userAgent: navigator.userAgent,
            browser: this._knowYourBrowser(),
            device: '',
            os_version: window.navigator.platform,
            browser_version: _getBrowserVersion(),
            isDesktop: _isDesktop(),
            isMobile: _isMobile(),
            //('ontouchstart' in document.documentElement && navigator.userAgent.match(/Mobi/)),
            isTablet: _isTablet()
        };
        /**
         * @return {?}
         */
        function _isMobile() {
            if (window.innerWidth >= 320 && window.innerWidth <= 767) {
                return true;
            }
            else {
                return false;
            }
        }
        /**
         * @return {?}
         */
        function _isTablet() {
            if (window.innerWidth >= 768 && window.innerWidth <= 979) {
                return true;
            }
            else {
                return false;
            }
        }
        /**
         * @return {?}
         */
        function _isDesktop() {
            if (window.innerWidth >= 980) {
                return true;
            }
            else {
                return false;
            }
        }
        /**
         * @return {?}
         */
        function _getBrowserVersion() {
            /** @type {?} */
            var ua = navigator.userAgent;
            /** @type {?} */
            var tem;
            /** @type {?} */
            var M = ua.match(/(opera|chrome|safari|firefox|msie|trident(?=\/))\/?\s*(\d+)/i) || [];
            if (/trident/i.test(M[1])) {
                tem = /\brv[ :]+(\d+)/g.exec(ua) || [];
                return 'IE ' + (tem[1] || '');
            }
            if (M[1] === 'Chrome') {
                tem = ua.match(/\b(OPR|Edge)\/(\d+)/);
                if (tem != null)
                    return tem.slice(1).join(' ').replace('OPR', 'Opera');
            }
            M = M[2] ? [M[1], M[2]] : [navigator.appName, navigator.appVersion, '-?'];
            if ((tem = ua.match(/version\/(\d+)/i)) != null)
                M.splice(1, 1, tem[1]);
            return M.join(' ');
        }
    }
}
DeviceDetectorService.decorators = [
    { type: Injectable, args: [{
                providedIn: 'root'
            },] }
];
/** @nocollapse */
DeviceDetectorService.ctorParameters = () => [];
/** @nocollapse */ DeviceDetectorService.ngInjectableDef = ɵɵdefineInjectable({ factory: function DeviceDetectorService_Factory() { return new DeviceDetectorService(); }, token: DeviceDetectorService, providedIn: "root" });

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
/**
 * @param {?} type
 * @param {?} value
 * @return {?}
 */
function invalidPipeArgumentError(type, value) {
    return Error(`InvalidPipeArgument: '${value}' for pipe '${ɵstringify(type)}'`);
}

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
class LowerCasePipe {
    /**
     * @param {?} value
     * @return {?}
     */
    transform(value) {
        // Transforms text to lowercase. 
        if (!value)
            return value;
        if (typeof value !== 'string') {
            throw invalidPipeArgumentError(LowerCasePipe, value);
        }
        return value.toLowerCase();
    }
}
LowerCasePipe.decorators = [
    { type: Pipe, args: [{ name: 'lowercase' },] }
];
/**
 * @param {?} word
 * @return {?}
 */
function titleCaseWord(word) {
    //Helper method to transform a single word to titlecase.
    if (!word)
        return word;
    return word[0].toUpperCase() + word.substr(1).toLowerCase();
}
class TitleCasePipe {
    /**
     * @param {?} value
     * @return {?}
     */
    transform(value) {
        //Transforms text to titlecase.
        if (!value)
            return value;
        if (typeof value !== 'string') {
            throw invalidPipeArgumentError(TitleCasePipe, value);
        }
        return value.split(/\b/g).map((/**
         * @param {?} word
         * @return {?}
         */
        word => titleCaseWord(word))).join('');
    }
}
TitleCasePipe.decorators = [
    { type: Pipe, args: [{ name: 'titlecase' },] }
];
class UpperCasePipe {
    /**
     * @param {?} value
     * @return {?}
     */
    transform(value) {
        /* Transforms text to uppercase. */
        if (!value)
            return value;
        if (typeof value !== 'string') {
            throw invalidPipeArgumentError(UpperCasePipe, value);
        }
        return value.toUpperCase();
    }
}
UpperCasePipe.decorators = [
    { type: Pipe, args: [{ name: 'uppercase' },] }
];

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
class GenerateUrlPipe {
    constructor() {
        this.placeholder = '{%s%}';
    }
    /**
     * @param {?} _url
     * @param {?=} _params
     * @return {?}
     */
    transform(_url, _params) {
        /** @type {?} */
        let _generatedUrl = _url;
        (_url.match(new RegExp(this.placeholder, 'g')) || []).forEach((/**
         * @param {?} _item
         * @param {?} _index
         * @return {?}
         */
        (_item, _index) => {
            _generatedUrl = _generatedUrl.replace(_item, _params[_index]);
        }));
        return _generatedUrl;
    }
}
GenerateUrlPipe.decorators = [
    { type: Pipe, args: [{
                name: 'generateUrl'
            },] }
];

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
class TrimPipe {
    /**
     * @param {?} _stringInput
     * @param {?} _maxLength
     * @return {?}
     */
    transform(_stringInput, _maxLength) {
        if ((_stringInput || '').length <= _maxLength)
            return _stringInput;
        else
            return _stringInput.substring(0, _maxLength - 2) + "..";
    }
}
TrimPipe.decorators = [
    { type: Pipe, args: [{
                name: 'trim'
            },] }
];

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
// 
class TimeagoPipe {
    /**
     * @param {?} changeDetectorRef
     * @param {?} ngZone
     */
    constructor(changeDetectorRef, ngZone) {
        this.changeDetectorRef = changeDetectorRef;
        this.ngZone = ngZone;
    }
    /**
     * @return {?}
     */
    ngOnDestroy() {
        this.removeTimer();
    }
    /**
     * @return {?}
     */
    removeTimer() {
        if (typeof timer !== 'undefined') {
            window.clearTimeout(timer);
            timer = null;
        }
    }
    /**
     * @param {?} seconds
     * @return {?}
     */
    getSecondsUntilUpdate(seconds) {
        /** @type {?} */
        let min = 60;
        /** @type {?} */
        let hr = min * 60;
        /** @type {?} */
        let day = hr * 24;
        if (seconds < min) {
            // less than 1 min, update every 2 secs
            return 2;
        }
        else if (seconds < hr) {
            // less than an hour, update every 30 secs
            return 30;
        }
        else if (seconds < day) {
            // less then a day, update every 5 mins
            return 300;
        }
        else {
            // update every hour
            return 3600;
        }
    }
    /**
     * @param {?} value
     * @param {?=} args
     * @return {?}
     */
    transform(value, args) {
        this.removeTimer();
        /** @type {?} */
        let d = new Date(value);
        /** @type {?} */
        let timer = "";
        /** @type {?} */
        let now = new Date();
        /** @type {?} */
        let seconds = Math.round(Math.abs((now.getTime() - d.getTime()) / 1000));
        /** @type {?} */
        let timeToUpdate = (Number.isNaN(seconds)) ? 1000 : this.getSecondsUntilUpdate(seconds) * 1000;
        timer = this.ngZone.runOutsideAngular((/**
         * @return {?}
         */
        () => {
            if (typeof window !== 'undefined') {
                return window.setTimeout((/**
                 * @return {?}
                 */
                () => {
                    this.ngZone.run((/**
                     * @return {?}
                     */
                    () => this.changeDetectorRef.markForCheck()));
                }), timeToUpdate);
            }
            return null;
        }));
        /** @type {?} */
        let minutes = Math.round(Math.abs(seconds / 60));
        /** @type {?} */
        let hours = Math.round(Math.abs(minutes / 60));
        /** @type {?} */
        let days = Math.round(Math.abs(hours / 24));
        /** @type {?} */
        let months = Math.round(Math.abs(days / 30.416));
        /** @type {?} */
        let years = Math.round(Math.abs(days / 365));
        if (Number.isNaN(seconds)) {
            return '';
        }
        else if (seconds <= 45) {
            return 'a few seconds ago';
        }
        else if (seconds <= 90) {
            return 'a minute ago';
        }
        else if (minutes <= 45) {
            return minutes + ' minutes ago';
        }
        else if (minutes <= 90) {
            return 'an hour ago';
        }
        else if (hours <= 22) {
            return hours + ' hours ago';
        }
        else if (hours <= 36) {
            return 'a day ago';
        }
        else if (days <= 25) {
            return days + ' days ago';
        }
        else if (days <= 45) {
            return 'a month ago';
        }
        else if (days <= 345) {
            return months + ' months ago';
        }
        else if (days <= 545) {
            return 'a year ago';
        }
        else {
            // (days > 545)
            return years + ' years ago';
        }
    }
}
TimeagoPipe.decorators = [
    { type: Pipe, args: [{
                name: 'timeago'
            },] }
];
/** @nocollapse */
TimeagoPipe.ctorParameters = () => [
    { type: ChangeDetectorRef },
    { type: NgZone }
];

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
class SearchtextPipe {
    /**
     * @param {?} value
     * @param {?} keys
     * @param {?} term
     * @return {?}
     */
    transform(value, keys, term) {
        if (!term)
            return value;
        return (value || []).filter((/**
         * @param {?} item
         * @return {?}
         */
        (item) => keys.split(',').some((/**
         * @param {?} key
         * @return {?}
         */
        key => item.hasOwnProperty(key) && new RegExp(term, 'gi').test(item[key])))));
    }
}
SearchtextPipe.decorators = [
    { type: Pipe, args: [{
                name: 'searchtext'
            },] }
];

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
class OrderByPipe {
    /**
     * @param {?} array
     * @param {?} orderField
     * @param {?} orderType
     * @return {?}
     */
    transform(array, orderField, orderType) {
        array.sort((/**
         * @param {?} a
         * @param {?} b
         * @return {?}
         */
        (a, b) => {
            /** @type {?} */
            let ae = a[orderField];
            /** @type {?} */
            let be = b[orderField];
            if (ae == undefined && be == undefined)
                return 0;
            if (ae == undefined && be != undefined)
                return orderType ? 1 : -1;
            if (ae != undefined && be == undefined)
                return orderType ? -1 : 1;
            if (ae == be)
                return 0;
            return orderType ? (ae.toString().toLowerCase() > be.toString().toLowerCase() ? -1 : 1) : (be.toString().toLowerCase() > ae.toString().toLowerCase() ? -1 : 1);
        }));
        return array;
    }
}
OrderByPipe.decorators = [
    { type: Pipe, args: [{
                name: 'orderBy'
            },] }
];

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
class KeysPipe {
    /**
     * @param {?} value
     * @param {?} args
     * @return {?}
     */
    transform(value, args) {
        /** @type {?} */
        let keys = [];
        for (let key in value) {
            keys.push({ key: key, value: value[key] });
        }
        return keys;
    }
}
KeysPipe.decorators = [
    { type: Pipe, args: [{
                name: 'keys'
            },] }
];

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
class IsEmptyPipe {
    /**
     * @param {?} value
     * @param {?=} args
     * @return {?}
     */
    transform(value, args) {
        for (let bar in value) {
            if (value.hasOwnProperty(bar)) {
                return true;
            }
        }
        return false;
    }
}
IsEmptyPipe.decorators = [
    { type: Pipe, args: [{
                name: 'isEmpty'
            },] }
];

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
class IndianCurrencyPipe {
    /**
     * @param {?} rsStr
     * @param {?=} args
     * @return {?}
     */
    transform(rsStr, args) {
        if (!isNaN(rsStr)) {
            /** @type {?} */
            var currencySymbol = '₹';
            //var output = Number(rsStr).toLocaleString('en-IN');   <-- This method is not working fine in all browsers!           
            /** @type {?} */
            var result = rsStr.toString().split('.');
            /** @type {?} */
            var lastThree = result[0].substring(result[0].length - 3);
            /** @type {?} */
            var otherNumbers = result[0].substring(0, result[0].length - 3);
            if (otherNumbers != '')
                lastThree = ',' + lastThree;
            /** @type {?} */
            var output = otherNumbers.replace(/\B(?=(\d{2})+(?!\d))/g, ",") + lastThree;
            if (result.length > 1) {
                output += "." + result[1];
            }
            return currencySymbol + output;
        }
    }
}
IndianCurrencyPipe.decorators = [
    { type: Pipe, args: [{
                name: 'indianCurrency'
            },] }
];

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
class NgxPipeModule {
}
NgxPipeModule.decorators = [
    { type: NgModule, args: [{
                providers: [],
                exports: [LowerCasePipe, TitleCasePipe, UpperCasePipe, GenerateUrlPipe, TrimPipe, TimeagoPipe,
                    SearchtextPipe, OrderByPipe, KeysPipe, IsEmptyPipe, IndianCurrencyPipe],
                declarations: [LowerCasePipe, TitleCasePipe, UpperCasePipe, GenerateUrlPipe, TrimPipe, TimeagoPipe,
                    SearchtextPipe, OrderByPipe, KeysPipe, IsEmptyPipe, IndianCurrencyPipe]
            },] }
];

export { CfUtilityComponent, CfUtilityModule, CfUtilityService, DeviceDetectorService, NgxPipeModule, PropagatorUtilService, ValidatorService, LowerCasePipe as ɵa, TitleCasePipe as ɵb, UpperCasePipe as ɵc, GenerateUrlPipe as ɵd, TrimPipe as ɵe, TimeagoPipe as ɵf, SearchtextPipe as ɵg, OrderByPipe as ɵh, KeysPipe as ɵi, IsEmptyPipe as ɵj, IndianCurrencyPipe as ɵk };
//# sourceMappingURL=cf-common-lib.js.map