ngx-sfc-common 0.0.0-watch

package/esm2020/lib/utils/collections.utils.mjs

@@ -0,0 +1,280 @@
+import { CommonConstants } from "../constants";
+import { SortingDirection } from "../enums";
+import { isDefined } from "./common.utils";
+import { isNullOrEmptyString } from "./string.utils";
+/**
+ * Return true if collection not empty
+ * @param collection Array of items
+ * @returns True if collection not empty
+ */
+export function any(collection) {
+    return isDefined(collection) && collection.length > 0;
+}
+/**
+ * Return true if collection has such value
+ * @param collection Array of items
+ * @param value Value to check
+ * @returns True if found value in collection
+ */
+export function hasItem(collection, value) {
+    return any(collection)
+        && collection.findIndex(item => item === value) !== CommonConstants.NOT_FOUND_INDEX;
+}
+/**
+ * Return true if collection has such value by predicate function
+ * @param collection Array of items
+ * @param predicate Function to define check logic
+ * @returns True if found value in collection
+ */
+export function hasItemBy(collection, predicate) {
+    return any(collection) && collection.findIndex(predicate) !== CommonConstants.NOT_FOUND_INDEX;
+}
+/**
+ * Return true if collection of objects has such value as object
+ * @param collection Array of objects
+ * @param property Property name
+ * @param value Value to check
+ * @returns True if found value in collection
+ */
+export function hasObjectItem(collection, // TODO <-- Array<T>
+property, value) {
+    return any(collection)
+        && collection.findIndex(item => item.hasOwnProperty(property)
+            && item[property] === value) !== CommonConstants.NOT_FOUND_INDEX;
+}
+/**
+ * Return value from collection by predicate function
+ * @param collection Array of items
+ * @param predicate Function to define search logic
+ * @returns Value from collection
+ */
+export function firstOrDefault(collection, predicate) {
+    return any(collection) ? collection?.find(predicate) : undefined;
+}
+/**
+ * Return first item from collection
+ * @param collection Array of items
+ * @returns First value from collection
+ */
+export function firstItem(collection) {
+    return any(collection) ? collection[0] : null;
+}
+/**
+ * Return last item from collection
+ * @param collection Array of items
+ * @returns Last value from collection
+ */
+export function lastItem(collection) {
+    return any(collection) ? collection[collection.length - 1] : null;
+}
+/**
+ * Return True if all values match predicate function
+ * @param collection Array of objects
+ * @param predicate Function to define check logic
+ * @returns True if all values match predicate
+ */
+export function all(collection, predicate) {
+    return any(collection) ? collection.filter(predicate).length == collection.length : false;
+}
+/**
+ * Return count by predicate
+ * @param collection Array of objects
+ * @param predicate Function to define check logic
+ * @returns Items count
+ */
+export function count(collection, predicate) {
+    return collection.filter(predicate).length;
+}
+/**
+ * Return items from collection by predicate function
+ * @param collection Array of items
+ * @param predicate Function to define search logic
+ * @returns Values from collection
+ */
+export function where(collection, predicate) {
+    return any(collection) ? collection.filter(predicate) : null;
+}
+/**
+ * Return sliced collection by page number and page size
+ * @param collection Array of items
+ * @param page Page number
+ * @param size Page size
+ * @returns Sliced collection
+ */
+export function skip(collection, page, size) {
+    if (any(collection)) {
+        let start = (page - 1) * size;
+        return collection.slice(start, start + size);
+    }
+    return collection;
+}
+export function sort(collection, direction = SortingDirection.Ascending) {
+    if (any(collection)) {
+        return direction == SortingDirection.Ascending
+            ? collection.sort((a, b) => a - b)
+            : collection.sort((a, b) => b - a);
+    }
+    return collection;
+}
+/**
+ * Return sorted collection of objects by property
+ * @param collection Array of items
+ * @param property Property name
+ * @param direction Sorting direction
+ * @returns Sorted collection
+ */
+export function sortBy(collection, property, direction) {
+    if (any(collection)) {
+        let _sortFunc = (a, b) => (t1, t2) => (a[property] > b[property] ? t1 : t2);
+        return direction == SortingDirection.Ascending
+            ? collection.sort((a, b) => _sortFunc(a, b)(1, -1))
+            : collection.sort((a, b) => _sortFunc(a, b)(-1, 1));
+    }
+    return collection;
+}
+/**
+ * Return sorted collection of objects by path
+ * @param collection Array of items
+ * @param path Path to property
+ * @param direction Sorting direction
+ * @returns Sorted collection
+ */
+export function sortByPath(collection, path, direction) {
+    if (any(collection)) {
+        if (isNullOrEmptyString(path))
+            throw new Error('Collection utils | Sort By Path function --> Path is empty.');
+        const pathParts = path.split('.');
+        if (!any(pathParts))
+            throw new Error('Collection utils | Sort By Path function --> Path is incorrect.');
+        const partsLength = pathParts.length;
+        collection.sort((a, b) => {
+            var i = 0;
+            while (i < partsLength) {
+                a = a[pathParts[i]];
+                b = b[pathParts[i]];
+                i++;
+            }
+            return direction == SortingDirection.Ascending
+                ? a >= b ? 1 : -1
+                : a > b ? -1 : 1;
+        });
+        return collection;
+    }
+    return collection;
+}
+/**
+ * Return collection without matches
+ * @param collection Array of items
+ * @returns Collection without matches
+ */
+export function distinct(collection) {
+    return any(collection)
+        ? collection.filter((value, index, self) => self.indexOf(value) === index)
+        : collection;
+}
+/**
+ * Return sum value from collection items by map function
+ * @param collection Array of items
+ * @param select Map function
+ * @returns Sum value of colection items
+ */
+export function sum(collection, select) {
+    return any(collection)
+        ? collection
+            .map(select)
+            .reduce((a, b) => { return a + b; }, 0)
+        : 0;
+}
+/**
+ * Return max value from collection items by map function
+ * @param collection Array of items
+ * @param select Map function
+ * @returns Max value of collection items
+ */
+export function max(collection, select) {
+    if (any(collection))
+        return Math.max(...collection.map(select));
+    throw new Error('Collection utils | Max function --> Collection is empty.');
+}
+/**
+ * Delete items from collection by predicate
+ * @param collection Array of items
+ * @param predicate Function to define remove logic
+ */
+export function remove(collection, predicate) {
+    var i = collection.length;
+    while (i--) {
+        if (predicate(collection[i])) {
+            collection.splice(i, 1);
+        }
+    }
+}
+/**
+ * Add item to collection
+ * @param collection Array of items
+ * @param item New item
+ * @param predicate Function to define if allowed to add new item
+ * @returns True if successfully added
+ */
+export function addItem(collection, item, predicate) {
+    if (!isDefined(collection))
+        collection = new Array();
+    if (isDefined(predicate) && predicate(item))
+        return false;
+    collection.push(item);
+    return true;
+}
+/**
+ * Delete item from collection
+ * @param collection Array of items
+ * @param item Item to delete
+ * @returns True if successfully removed
+ */
+export function removeItem(collection, item) {
+    if (isDefined(item) && hasItem(collection, item)) {
+        collection.splice(collection.indexOf(item), 1);
+        return true;
+    }
+    return false;
+}
+/**
+ * Delete item from collection by predicate
+ * @param collection Array of items
+ * @param predicate Function to define remove logic
+ * @returns True if successfully removed
+ */
+export function removeItemBy(collection, predicate) {
+    const foundItem = firstOrDefault(collection, predicate);
+    if (isDefined(foundItem)) {
+        collection.splice(collection.indexOf(foundItem), 1);
+        return true;
+    }
+    return false;
+}
+/**
+ * Update item in collection by predicate
+ * @param collection Array of items
+ * @param predicate Function to define item for deleting
+ * @returns True if successfully removed
+ */
+export function updateItemBy(collection, predicate, newItem) {
+    const itemIndex = collection.findIndex(predicate);
+    if (itemIndex !== CommonConstants.NOT_FOUND_INDEX) {
+        const result = collection.slice(0);
+        result[itemIndex] = {
+            ...collection[itemIndex],
+            ...newItem
+        };
+        return result;
+    }
+    return null;
+}
+/**
+ * Return collection or empty if collection is not defined
+ * @param collection Array of items
+ * @returns Collection or empty
+ */
+export function getCollectionOrEmpty(collection) {
+    return isDefined(collection) ? collection : [];
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"collections.utils.js","sourceRoot":"","sources":["../../../../../projects/ngx-sfc-common/src/lib/utils/collections.utils.ts"],"names":[],"mappings":"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","sourcesContent":["import { CommonConstants } from \"../constants\";\r\nimport { SortingDirection } from \"../enums\";\r\nimport { isDefined } from \"./common.utils\";\r\nimport { isNullOrEmptyString } from \"./string.utils\";\r\n\r\n/**\r\n * Return true if collection not empty\r\n * @param collection Array of items\r\n * @returns True if collection not empty\r\n */\r\nexport function any<T>(collection: Array<T> | null | undefined): boolean {\r\n    return isDefined(collection) && (collection as Array<T>).length > 0;\r\n}\r\n\r\n/**\r\n * Return true if collection has such value\r\n * @param collection Array of items\r\n * @param value Value to check\r\n * @returns True if found value in collection\r\n */\r\nexport function hasItem<T>(collection: Array<T>, value: T): boolean {\r\n    return any(collection)\r\n        && collection.findIndex(item => item === value) !== CommonConstants.NOT_FOUND_INDEX;\r\n}\r\n\r\n/**\r\n * Return true if collection has such value by predicate function\r\n * @param collection Array of items\r\n * @param predicate Function to define check logic\r\n * @returns True if found value in collection\r\n */\r\nexport function hasItemBy<T>(collection: Array<T>, predicate: (item: T) => boolean): boolean {\r\n    return any(collection) && collection.findIndex(predicate) !== CommonConstants.NOT_FOUND_INDEX;\r\n}\r\n\r\n/**\r\n * Return true if collection of objects has such value as object\r\n * @param collection Array of objects\r\n * @param property Property name\r\n * @param value Value to check\r\n * @returns True if found value in collection\r\n */\r\nexport function hasObjectItem<T>(collection: Array<any>, // TODO <-- Array<T>\r\n    property: string, value: T): boolean {\r\n    return any(collection)\r\n        && collection.findIndex(item =>\r\n            item.hasOwnProperty(property)\r\n            && item[property] === value) !== CommonConstants.NOT_FOUND_INDEX;\r\n}\r\n\r\n/**\r\n * Return value from collection by predicate function\r\n * @param collection Array of items\r\n * @param predicate Function to define search logic\r\n * @returns Value from collection\r\n */\r\nexport function firstOrDefault<T>(collection: Array<T> | null | undefined,\r\n    predicate: (item: T) => boolean)\r\n    : T | undefined {\r\n    return any(collection) ? collection?.find(predicate) : undefined;\r\n}\r\n\r\n/**\r\n * Return first item from collection\r\n * @param collection Array of items\r\n * @returns First value from collection\r\n */\r\nexport function firstItem<T>(collection: Array<T>): T | null | undefined {\r\n    return any(collection) ? collection[0] : null;\r\n}\r\n\r\n/**\r\n * Return last item from collection\r\n * @param collection Array of items\r\n * @returns Last value from collection\r\n */\r\nexport function lastItem<T>(collection: Array<T>): T | null | undefined {\r\n    return any(collection) ? collection[collection.length - 1] : null;\r\n}\r\n\r\n/**\r\n * Return True if all values match predicate function\r\n * @param collection Array of objects\r\n * @param predicate Function to define check logic\r\n * @returns True if all values match predicate\r\n */\r\nexport function all<T>(collection: Array<T>, predicate: (item: T) => boolean): boolean {\r\n    return any(collection) ? collection.filter(predicate).length == collection.length : false;\r\n}\r\n\r\n/**\r\n * Return count by predicate\r\n * @param collection Array of objects\r\n * @param predicate Function to define check logic\r\n * @returns Items count\r\n */\r\n export function count<T>(collection: Array<T>, predicate: (item: T) => boolean): number {\r\n    return collection.filter(predicate).length;\r\n}\r\n\r\n/**\r\n * Return items from collection by predicate function\r\n * @param collection Array of items\r\n * @param predicate Function to define search logic\r\n * @returns Values from collection\r\n */\r\nexport function where<T>(collection: Array<T>, predicate: (item: T) => boolean)\r\n    : Array<T> | null | undefined {\r\n    return any(collection) ? collection.filter(predicate) : null;\r\n}\r\n\r\n/**\r\n * Return sliced collection by page number and page size\r\n * @param collection Array of items\r\n * @param page Page number\r\n * @param size Page size\r\n * @returns Sliced collection\r\n */\r\nexport function skip<T>(collection: Array<T>, page: number, size: number): Array<T> {\r\n    if (any(collection)) {\r\n        let start = (page - 1) * size;\r\n        return collection.slice(start, start + size);\r\n    }\r\n\r\n    return collection;\r\n}\r\n\r\nexport function sort<T>(collection: Array<T>, direction: SortingDirection = SortingDirection.Ascending): Array<T> {\r\n    if (any(collection)) {\r\n        return direction == SortingDirection.Ascending\r\n            ? collection.sort((a: any, b: any) => a - b)\r\n            : collection.sort((a: any, b: any) => b - a);\r\n    }\r\n\r\n    return collection;\r\n}\r\n\r\n/**\r\n * Return sorted collection of objects by property\r\n * @param collection Array of items\r\n * @param property Property name\r\n * @param direction Sorting direction\r\n * @returns Sorted collection\r\n */\r\nexport function sortBy<T>(collection: Array<T>, property: string,\r\n    direction: SortingDirection): Array<T> {\r\n    if (any(collection)) {\r\n        let _sortFunc = (a: any, b: any) =>\r\n            (t1: number, t2: number) =>\r\n                (a[property] > b[property] ? t1 : t2);\r\n\r\n        return direction == SortingDirection.Ascending\r\n            ? collection.sort((a: any, b: any) => _sortFunc(a, b)(1, -1))\r\n            : collection.sort((a: any, b: any) => _sortFunc(a, b)(-1, 1));\r\n    }\r\n\r\n    return collection;\r\n}\r\n\r\n/**\r\n * Return sorted collection of objects by path\r\n * @param collection Array of items\r\n * @param path Path to property\r\n * @param direction Sorting direction\r\n * @returns Sorted collection\r\n */\r\nexport function sortByPath<T>(collection: Array<T>, path: string, direction: SortingDirection)\r\n    : Array<T> {\r\n    if (any(collection)) {\r\n        if (isNullOrEmptyString(path))\r\n            throw new Error('Collection utils | Sort By Path function --> Path is empty.');\r\n\r\n        const pathParts = path.split('.');\r\n\r\n        if (!any(pathParts))\r\n            throw new Error('Collection utils | Sort By Path function --> Path is incorrect.');\r\n\r\n        const partsLength = pathParts.length;\r\n\r\n        collection.sort((a: any, b: any) => {\r\n            var i = 0;\r\n            while (i < partsLength) { a = a[pathParts[i]]; b = b[pathParts[i]]; i++; }\r\n\r\n            return direction == SortingDirection.Ascending\r\n                ? a >= b ? 1 : -1\r\n                : a > b ? -1 : 1;\r\n        });\r\n\r\n        return collection;\r\n    }\r\n\r\n    return collection;\r\n}\r\n\r\n/**\r\n * Return collection without matches\r\n * @param collection Array of items\r\n * @returns Collection without matches\r\n */\r\nexport function distinct<T>(collection: Array<T>): Array<T> {\r\n    return any(collection)\r\n        ? collection.filter((value, index, self) => self.indexOf(value) === index)\r\n        : collection;\r\n}\r\n\r\n/**\r\n * Return sum value from collection items by map function\r\n * @param collection Array of items\r\n * @param select Map function\r\n * @returns Sum value of colection items\r\n */\r\nexport function sum<T>(collection: Array<T>, select: (item: T) => number): number {\r\n    return any(collection)\r\n        ? collection\r\n            .map(select)\r\n            .reduce((a, b) => { return a + b }, 0)\r\n        : 0;\r\n}\r\n\r\n/**\r\n * Return max value from collection items by map function\r\n * @param collection Array of items\r\n * @param select Map function\r\n * @returns Max value of collection items\r\n */\r\nexport function max<T>(collection: Array<T>, select: (item: T) => number): number {\r\n    if (any(collection))\r\n        return Math.max(...collection.map(select));\r\n\r\n    throw new Error('Collection utils | Max function --> Collection is empty.')\r\n}\r\n\r\n/**\r\n * Delete items from collection by predicate\r\n * @param collection Array of items\r\n * @param predicate Function to define remove logic\r\n */\r\nexport function remove<T>(collection: Array<T>, predicate: (item: T) => boolean): void {\r\n    var i = collection.length;\r\n    while (i--) {\r\n        if (predicate(collection[i])) {\r\n            collection.splice(i, 1);\r\n        }\r\n    }\r\n}\r\n\r\n/**\r\n * Add item to collection\r\n * @param collection Array of items\r\n * @param item New item\r\n * @param predicate Function to define if allowed to add new item\r\n * @returns True if successfully added\r\n */\r\nexport function addItem<T>(collection: Array<T>, item: T,\r\n    predicate: (item: T) => boolean): boolean {\r\n\r\n    if (!isDefined(collection))\r\n        collection = new Array<T>();\r\n\r\n    if (isDefined(predicate) && predicate(item))\r\n        return false;\r\n\r\n    collection.push(item);\r\n\r\n    return true;\r\n}\r\n\r\n/**\r\n * Delete item from collection\r\n * @param collection Array of items\r\n * @param item Item to delete\r\n * @returns True if successfully removed\r\n */\r\nexport function removeItem<T>(collection: Array<T>, item: T): boolean {\r\n    if (isDefined(item) && hasItem(collection, item)) {\r\n        collection.splice(collection.indexOf(item), 1);\r\n        return true;\r\n    }\r\n\r\n    return false;\r\n}\r\n\r\n/**\r\n * Delete item from collection by predicate\r\n * @param collection Array of items\r\n * @param predicate Function to define remove logic\r\n * @returns True if successfully removed\r\n */\r\nexport function removeItemBy<T>(collection: Array<T>, predicate: (item: T) => boolean): boolean {\r\n    const foundItem: T | null | undefined = firstOrDefault(collection, predicate);\r\n    if (isDefined(foundItem)) {\r\n        collection.splice(collection.indexOf(foundItem as T), 1);\r\n        return true;\r\n    }\r\n\r\n    return false;\r\n}\r\n\r\n/**\r\n * Update item in collection by predicate\r\n * @param collection Array of items\r\n * @param predicate Function to define item for deleting\r\n * @returns True if successfully removed\r\n */\r\nexport function updateItemBy<T>(collection: Array<T>, predicate: (item: T) => boolean, newItem: T)\r\n    : Array<T> | null {\r\n    const itemIndex = collection.findIndex(predicate);\r\n\r\n    if (itemIndex !== CommonConstants.NOT_FOUND_INDEX) {\r\n        const result = collection.slice(0);\r\n        result[itemIndex] = {\r\n            ...collection[itemIndex],\r\n            ...newItem\r\n        };\r\n        return result\r\n    }\r\n\r\n    return null;\r\n}\r\n\r\n/**\r\n * Return collection or empty if collection is not defined\r\n * @param collection Array of items\r\n * @returns Collection or empty\r\n */\r\nexport function getCollectionOrEmpty<T>(collection: Array<T>): Array<T> {\r\n    return isDefined(collection) ? collection : [];\r\n}"]}

package/esm2020/lib/utils/common.utils.mjs

@@ -0,0 +1,184 @@
+import { Observable } from 'rxjs';
+import { isEqualDateTimes } from './date-time.utils';
+/**
+ * Return true if value defined
+ * @param value Value to check
+ * @returns True if value is not null and defined
+ */
+export function isDefined(value) {
+    return value !== undefined && value !== null;
+}
+/**
+ * Return true if value is object
+ * @param value Value to check
+ * @returns True if value is object
+ */
+export function isObject(value) {
+    return (isDefined(value) && typeof value === 'object'
+        && !Array.isArray(value)
+        && !(value instanceof Date || value instanceof File));
+}
+/**
+ * Return true if data is observable
+ * @param data Object to check
+ * @returns True if data is observable
+ */
+export function isAsyncData(data) {
+    return data instanceof Observable;
+}
+/**
+ * Return extended object with new property
+ * @param obj Object to extend by property
+ * @param property New property name
+ * @param value Value for new property
+ * @returns Extended object with new property
+ */
+export function addPropertyToObject(obj, property, value = null) {
+    if (isDefined(property) && !obj.hasOwnProperty(property)) {
+        let newObj = {};
+        newObj[property] = value;
+        obj = { ...obj, ...newObj };
+    }
+    return obj;
+}
+/**
+ * Remove property from object
+ * @param obj Object for removing property
+ * @param property Property name to remove
+ */
+export function removePropertyFromObject(obj, property) {
+    if (obj.hasOwnProperty(property)) {
+        delete obj[property];
+    }
+}
+/**
+  * Deep merge object with others
+  * @param target Object to merge
+  * @param sources
+  */
+/**
+ * Deep merge object with others
+ * @param target  Object to merge
+ * @param sources Objects to be merged with target
+ * @returns Merged object
+ */
+export function mergeDeep(target, ...sources) {
+    if (!sources.length)
+        return target;
+    const source = sources.shift();
+    if (isObject(target) && isObject(source)) {
+        for (const key in source) {
+            if (isObject(source[key])) {
+                if (!target[key])
+                    Object.assign(target, { [key]: {} });
+                mergeDeep(target[key], source[key]);
+            }
+            else {
+                Object.assign(target, { [key]: source[key] });
+            }
+        }
+    }
+    return mergeDeep(target, ...sources);
+}
+/**
+ * Get type's property name safety
+ * @param name KeyOf property
+ * @returns Type's property name
+ */
+export const nameof = (name) => name;
+/**
+   * Determines if the input is a Number or something that can be coerced to a Number
+   * @param - The input to be tested
+   * @returns - An indication if the input is a Number or can be coerced to a Number
+   */
+export function isNumeric(number) {
+    return !isNaN(parseFloat(number));
+}
+/**
+ * Return true if current browser is Chrome
+ * @returns If current browser is Chrome
+ */
+export function isChromeBrowser() {
+    return /Chrome/.test(navigator.userAgent) && /Google Inc/.test(navigator.vendor);
+}
+/**
+ * Return true if value is valid email address
+ * @returns True if it's valid email address
+ */
+export function isEmail(value) {
+    return isDefined(value.match(/^(([^<>()[\]\\.,;:\s@\"]+(\.[^<>()[\]\\.,;:\s@\"]+)*)|(\".+\"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/));
+}
+/**
+ * Return true if string is "true"
+ * @returns parsed string as boolean
+ */
+export function parseBoolean(value) {
+    return /^true$/i.test(value);
+}
+/**
+ * Return true if values equal
+ * @param obj1 First value to compare
+ * @param obj2 Second value to compare
+ * @returns True if equal
+ */
+export function isEqual(obj1, obj2) {
+    /**
+     * More accurately check the type of a JavaScript object
+     * @param  {Object} obj The object
+     * @return {String}     The object type
+     */
+    function getType(obj) {
+        return Object.prototype.toString.call(obj).slice(8, -1).toLowerCase();
+    }
+    function areArraysEqual() {
+        // Check length
+        if (obj1.length !== obj2.length)
+            return false;
+        // Check each item in the array
+        for (let i = 0; i < obj1.length; i++) {
+            if (!isEqual(obj1[i], obj2[i]))
+                return false;
+        }
+        // If no errors, return true
+        return true;
+    }
+    function areObjectsEqual() {
+        if (Object.keys(obj1).length !== Object.keys(obj2).length)
+            return false;
+        // Check each item in the object
+        for (let key in obj1) {
+            if (Object.prototype.hasOwnProperty.call(obj1, key)) {
+                if (!isEqual(obj1[key], obj2[key])) {
+                    return false;
+                }
+            }
+        }
+        // If no errors, return true
+        return true;
+    }
+    function areFunctionsEqual() {
+        return obj1.toString() === obj2.toString();
+    }
+    function arePrimativesEqual() {
+        return obj1 === obj2;
+    }
+    function areDatesEqual() {
+        return isEqualDateTimes(obj1, obj2);
+    }
+    // Get the object type
+    let type = getType(obj1);
+    // If the two items are not the same type, return false
+    if (type !== getType(obj2))
+        return false;
+    // Compare based on type
+    if (type === 'array')
+        return areArraysEqual();
+    if (type === 'date')
+        return areDatesEqual();
+    if (type === 'object')
+        return areObjectsEqual();
+    if (type === 'function')
+        return areFunctionsEqual();
+    return arePrimativesEqual();
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"common.utils.js","sourceRoot":"","sources":["../../../../../projects/ngx-sfc-common/src/lib/utils/common.utils.ts"],"names":[],"mappings":"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","sourcesContent":["import { Observable } from 'rxjs';\r\nimport { isEqualDateTimes } from './date-time.utils';\r\n\r\n/**\r\n * Return true if value defined\r\n * @param value Value to check\r\n * @returns True if value is not null and defined\r\n */\r\nexport function isDefined<T>(value: T | undefined | null): boolean {\r\n    return <T>value !== undefined && <T>value !== null;\r\n}\r\n\r\n/**\r\n * Return true if value is object\r\n * @param value Value to check\r\n * @returns True if value is object\r\n */\r\nexport function isObject(value: any): boolean {\r\n    return (isDefined(value) && typeof value === 'object'\r\n        && !Array.isArray(value)\r\n        && !(value instanceof Date || value instanceof File));\r\n}\r\n\r\n/**\r\n * Return true if data is observable\r\n * @param data Object to check\r\n * @returns True if data is observable\r\n */\r\nexport function isAsyncData(data: any) {\r\n    return data instanceof Observable;\r\n}\r\n\r\n/**\r\n * Return extended object with new property\r\n * @param obj Object to extend by property\r\n * @param property New property name \r\n * @param value Value for new property\r\n * @returns Extended object with new property\r\n */\r\nexport function addPropertyToObject(obj: any, property: string, value: any = null): any {\r\n    if (isDefined(property) && !obj.hasOwnProperty(property)) {\r\n        let newObj: any = {};\r\n        newObj[property] = value;\r\n        obj = { ...obj, ...newObj };\r\n    }\r\n\r\n    return obj;\r\n}\r\n\r\n/**\r\n * Remove property from object\r\n * @param obj Object for removing property\r\n * @param property Property name to remove\r\n */\r\nexport function removePropertyFromObject(obj: any, property: string): void {\r\n    if (obj.hasOwnProperty(property)) {\r\n        delete obj[property];\r\n    }\r\n}\r\n\r\n/**\r\n  * Deep merge object with others\r\n  * @param target Object to merge\r\n  * @param sources \r\n  */\r\n\r\n/**\r\n * Deep merge object with others\r\n * @param target  Object to merge\r\n * @param sources Objects to be merged with target\r\n * @returns Merged object\r\n */\r\nexport function mergeDeep(target: any, ...sources: any[]): any {\r\n    if (!sources.length)\r\n        return target;\r\n\r\n    const source = sources.shift();\r\n\r\n    if (isObject(target) && isObject(source)) {\r\n        for (const key in source) {\r\n            if (isObject(source[key])) {\r\n                if (!target[key]) Object.assign(target, { [key]: {} });\r\n                mergeDeep(target[key], source[key]);\r\n            } else {\r\n                Object.assign(target, { [key]: source[key] });\r\n            }\r\n        }\r\n    }\r\n\r\n    return mergeDeep(target, ...sources);\r\n}\r\n\r\n/**\r\n * Get type's property name safety\r\n * @param name KeyOf property\r\n * @returns Type's property name\r\n */\r\nexport const nameof = <T>(name: keyof T) => name;\r\n\r\n/**\r\n   * Determines if the input is a Number or something that can be coerced to a Number\r\n   * @param - The input to be tested\r\n   * @returns - An indication if the input is a Number or can be coerced to a Number\r\n   */\r\nexport function isNumeric(number: any): boolean {\r\n    return !isNaN(parseFloat(number));\r\n}\r\n\r\n/**\r\n * Return true if current browser is Chrome\r\n * @returns If current browser is Chrome\r\n */\r\nexport function isChromeBrowser(): boolean {\r\n    return /Chrome/.test(navigator.userAgent) && /Google Inc/.test(navigator.vendor);\r\n}\r\n\r\n/**\r\n * Return true if value is valid email address\r\n * @returns True if it's valid email address\r\n */\r\nexport function isEmail(value: string): boolean {\r\n    return isDefined(value.match(\r\n        /^(([^<>()[\\]\\\\.,;:\\s@\\\"]+(\\.[^<>()[\\]\\\\.,;:\\s@\\\"]+)*)|(\\\".+\\\"))@((\\[[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}\\])|(([a-zA-Z\\-0-9]+\\.)+[a-zA-Z]{2,}))$/\r\n    ));\r\n}\r\n\r\n/**\r\n * Return true if string is \"true\"\r\n * @returns parsed string as boolean\r\n */\r\nexport function parseBoolean(value: string): boolean {\r\n    return /^true$/i.test(value);\r\n}\r\n\r\n/**\r\n * Return true if values equal\r\n * @param obj1 First value to compare\r\n * @param obj2 Second value to compare\r\n * @returns True if equal\r\n */\r\n export function isEqual(obj1: any, obj2: any) {\r\n\r\n    /**\r\n     * More accurately check the type of a JavaScript object\r\n     * @param  {Object} obj The object\r\n     * @return {String}     The object type\r\n     */\r\n    function getType(obj: any) {\r\n      return Object.prototype.toString.call(obj).slice(8, -1).toLowerCase();\r\n    }\r\n  \r\n    function areArraysEqual() {\r\n  \r\n      // Check length\r\n      if (obj1.length !== obj2.length) return false;\r\n  \r\n      // Check each item in the array\r\n      for (let i = 0; i < obj1.length; i++) {\r\n        if (!isEqual(obj1[i], obj2[i])) return false;\r\n      }\r\n  \r\n      // If no errors, return true\r\n      return true;\r\n  \r\n    }\r\n  \r\n    function areObjectsEqual() {\r\n  \r\n      if (Object.keys(obj1).length !== Object.keys(obj2).length) return false;\r\n  \r\n      // Check each item in the object\r\n      for (let key in obj1) {\r\n        if (Object.prototype.hasOwnProperty.call(obj1, key)) {\r\n          if (!isEqual(obj1[key], obj2[key])) {\r\n            \r\n            return false;\r\n          }\r\n        }\r\n      }\r\n  \r\n      // If no errors, return true\r\n      return true;\r\n  \r\n    }\r\n  \r\n    function areFunctionsEqual() {\r\n      return obj1.toString() === obj2.toString();\r\n    }\r\n  \r\n    function arePrimativesEqual() {\r\n      return obj1 === obj2;\r\n    }\r\n  \r\n    function areDatesEqual() {\r\n      return isEqualDateTimes(obj1, obj2);\r\n    }\r\n  \r\n    // Get the object type\r\n    let type = getType(obj1);\r\n  \r\n    // If the two items are not the same type, return false\r\n    if (type !== getType(obj2)) return false;\r\n  \r\n    // Compare based on type\r\n    if (type === 'array') return areArraysEqual();\r\n  \r\n    if (type === 'date') return areDatesEqual();\r\n  \r\n    if (type === 'object') return areObjectsEqual();\r\n  \r\n    if (type === 'function') return areFunctionsEqual();\r\n  \r\n    return arePrimativesEqual();\r\n  }"]}