@qrvey/utils 1.1.2-0 → 1.1.4

package/src/filters/adapters/logicToFlatUI.ts

@@ -1,10 +1,11 @@
 // FROM Logic structure = Old logic structure (v2.0)
 // TO Logic structure = Cleaner logic structure
 
+import { adaptDateGroupingProperty } from ".";
 import { COLUMN } from "../../constants";
-import { isEmpty, _get } from "../../general";
+import { isEmpty, _get, _hasProperty } from "../../general";
 import { FILTER_BACKEND_VALIDATOR, FILTER_SCOPE, FILTER_VALIDATOR_VALUE } from "../constants";
-import { getFilterid, getUIValues, isNullValidator } from "../helpers";
+import { getFilterid, getUIValues, isNullValidator, } from "../helpers";
 import { IFSValueRanking, IFUFlattenedFilter, OLD_IFilterDetail, OLD_IFilterExpression, OLD_IFilterLogic } from "../interfaces";
 
 /**
@@ -19,81 +20,97 @@ export function logicToFlatUI(logics: OLD_IFilterLogic[] = []): IFUFlattenedFilt
     logics.forEach(scopeItem => {
         if (scopeItem.filters.length > 0) {
             scopeItem.filters.forEach(filterItem => {
-                (filterItem.expressions[0].expressions as OLD_IFilterExpression[]).forEach((expression: OLD_IFilterExpression) => {
-                    const uiExtras = expression.uiExtras;
-                    const index = uiExtras.column.type === COLUMN.RANKING ? getFilter(uFilters, expression.uiExtras, true) as number : -1;
-                    if (index === -1 && (!uiExtras.nullValues || expression.validationType !== FILTER_BACKEND_VALIDATOR.IS_NULL)) {
-                        const scopeid = scopeItem.scope !== FILTER_SCOPE.GLOBAL ? _get(scopeItem, 'uiExtras.scopeid') : undefined;
-                        const info = !isEmpty(uiExtras.info) ? { icon: uiExtras.info.icon, label: uiExtras.info.label } : undefined;
-                        const uFilter: IFUFlattenedFilter = {
-                            collapsed: uiExtras.collapsed,
-                            column: {
-                                id: uiExtras.column?.id,
-                                formulaType: uiExtras.column?.formulaType,
-                                linkid: uiExtras.column?.linkid,
-                                linked: uiExtras.column?.linked,
-                                qrveyid: uiExtras.column?.qrveyid,
-                                aggregate: uiExtras.column?.aggregate?.label,
-                                calculation: uiExtras.column?.calculation?.value,
-                                label: uiExtras.column?.text,
-                                property: uiExtras.column.property,
-                                sorting: uiExtras.column.sorting,
-                                outputFormat: uiExtras.column?.outputFormat,
-                                type: uiExtras.column?.type,
-                            },
-                            dateSection: uiExtras.dateSection,
-                            displayed: true,
-                            enabled: expression.enabled,
-                            extras: {
-                               ...uiExtras.extras,
-                                panelid: uiExtras.panelid,
-                                filterLabel: uiExtras.panelName,
-                                info,
-                                scopeid,
-                                scope: scopeItem.scope,
-                                section: uiExtras.section,
-                                scopeInfo: {
-                                    collapsed: scopeItem.uiExtras?.collapsed,
-                                    enabled: scopeItem.enabled,
-                                    displayed: true,
-                                    scope: scopeItem.scope,
-                                    scopeid,
-                                },
-                                dataset: {
-                                    collapsed: false,
-                                    enabled: true,
-                                    displayed: true,
-                                    qrveyid: uiExtras.column?.qrveyid,
-                                    label: uiExtras.column?.dataset?.name,
-                                    linkid: uiExtras.column?.linkid,
-                                },
-                            },
-                            filterid: undefined,
-                            lookupDisplayIndex: uiExtras.lookupDisplayIndex,
-                            nullValues: uiExtras.nullValues,
-                            operator: uiExtras.operator,
-                            property: uiExtras.property,
-                            uiValues: getUIValues(uiExtras as any),
-                            validator: uiExtras.validator,
-                            values: getValues(uiExtras),
-                        };
-                        uFilter.filterid = getFilterid(uFilter);
-                        uFilters.push(uFilter);
-                    }
-                    if (uiExtras.column.type === COLUMN.RANKING && isEmpty(uiExtras.column.aggregate)) {
-                        // Restore uiExtras.values array into single IFilterDetail object values array
-                        if (index > -1) uFilters[index].values.push(uiExtras.values[0]);
-                        const refinedRankingValues = refineRankingValues((index > -1 ? uFilters[index].values : uiExtras.values ) as IFSValueRanking[][], uiExtras.uiValue);
-                        if (index > -1) uFilters[index].values = refinedRankingValues;
-                        else uFilters[uFilters.length - 1].values = refinedRankingValues;
-                    }
+                filterItem.expressions.forEach((expression1: OLD_IFilterExpression) => {
+                    _hasProperty(expression1, 'expressions') ? expression1.expressions.forEach((expression2: OLD_IFilterExpression) => {
+                        buildFilterByExpression(expression2, scopeItem, uFilters);
+                    }) : buildFilterByExpression(expression1, scopeItem, uFilters);
                 });
+                // (filterItem.expressions[0].expressions as OLD_IFilterExpression[]).forEach((expression: OLD_IFilterExpression) => {
+                //     buildFilterByExpression(expression, scopeItem, uFilters);
+                // });
             });
         }
     });
     return uFilters;
 }
 
+function buildFilterByExpression(expression: OLD_IFilterExpression, scopeItem: OLD_IFilterLogic, uFilters: IFUFlattenedFilter[]) {
+    const uiExtras = expression.uiExtras;
+    const index = uiExtras.column.type === COLUMN.RANKING ? getFilter(uFilters, expression.uiExtras, true) as number : -1;
+    if (index === -1 && (!uiExtras.nullValues || expression.validationType !== FILTER_BACKEND_VALIDATOR.IS_NULL)) {
+        const uFilter: IFUFlattenedFilter = getFilterByExpression(expression, scopeItem);
+        uFilter.filterid = getFilterid(uFilter);
+        uFilters.push(uFilter);
+    }
+    if (uiExtras.column.type === COLUMN.RANKING && isEmpty(uiExtras.column.aggregate)) {
+        // Restore uiExtras.values array into single IFilterDetail object values array
+        if (index > -1) uFilters[index].values.push(uiExtras.values[0]);
+        const refinedRankingValues = refineRankingValues((index > -1 ? uFilters[index].values : uiExtras.values ) as IFSValueRanking[][], uiExtras.uiValue);
+        if (index > -1) uFilters[index].values = refinedRankingValues;
+        else uFilters[uFilters.length - 1].values = refinedRankingValues;
+    }
+}
+
+function getFilterByExpression(expression: OLD_IFilterExpression, scopeItem: OLD_IFilterLogic) {
+    const uiExtras = expression.uiExtras;
+    const scopeid = scopeItem.scope !== FILTER_SCOPE.GLOBAL ? _get(scopeItem, 'uiExtras.scopeid') : undefined;
+    const info = !isEmpty(uiExtras.info) ? { icon: uiExtras.info.icon, label: uiExtras.info.label } : undefined;
+    const property = adaptDateGroupingProperty(uiExtras.property);
+
+    return {
+        collapsed: uiExtras.collapsed,
+        column: {
+            id: uiExtras.column?.id,
+            formulaType: uiExtras.column?.formulaType,
+            linkid: uiExtras.column?.linkid,
+            linked: uiExtras.column?.linked,
+            qrveyid: uiExtras.column?.qrveyid,
+            aggregate: uiExtras.column?.aggregate?.label,
+            calculation: uiExtras.column?.calculation?.value,
+            label: uiExtras.column?.text,
+            property: uiExtras.column.property,
+            sorting: uiExtras.column.sorting,
+            outputFormat: uiExtras.column?.outputFormat,
+            type: uiExtras.column?.type,
+        },
+        dateSection: uiExtras.dateSection,
+        displayed: true,
+        enabled: expression.enabled,
+        extras: {
+            ...uiExtras.extras,
+            panelid: uiExtras.panelid,
+            filterLabel: uiExtras.panelName,
+            info,
+            scopeid,
+            scope: scopeItem.scope,
+            section: uiExtras.section,
+            scopeInfo: {
+                collapsed: scopeItem.uiExtras?.collapsed,
+                enabled: scopeItem.enabled,
+                displayed: true,
+                scope: scopeItem.scope,
+                scopeid,
+            },
+            dataset: {
+                collapsed: false,
+                enabled: true,
+                displayed: true,
+                qrveyid: uiExtras.column?.qrveyid,
+                label: uiExtras.column?.dataset?.name,
+                linkid: uiExtras.column?.linkid,
+            },
+        },
+        filterid: undefined,
+        lookupDisplayIndex: uiExtras.lookupDisplayIndex,
+        nullValues: uiExtras.nullValues,
+        operator: uiExtras.operator,
+        property,
+        uiValues: getUIValues(uiExtras as any),
+        validator: uiExtras.validator,
+        values: getValues(uiExtras),
+    };
+}
+
 function getValues(uiExtras: OLD_IFilterDetail) {
     if (isNullValidator(uiExtras.validator) && isEmpty(uiExtras.values)) {
         return [{ value: FILTER_VALIDATOR_VALUE[uiExtras.validator].label, enabled: uiExtras.uiValue[0].enabled != null ? uiExtras.uiValue[0].enabled : true }];

package/src/filters/helpers/backend/getAggFiltersBySummaryIndex.ts

@@ -9,7 +9,7 @@ import { IFBFilterAggregate } from "../../interfaces";
  */
 export function getAggFiltersBySummaryIndex(aggFilters: IFBFilterAggregate, summaryIndex: number): IFBFilterAggregate {
     if (!aggFilters) return undefined;
-    const expressions = filterNestedTree(aggFilters.expressions, 'expressions', expression => {
+    const expressions = filterNestedTree(aggFilters.expressions as any, 'expressions', expression => {
         const isSameSummary = expression.summaryIndex === summaryIndex;
         if (isSameSummary) expression.summaryIndex = 0;
         return isSameSummary;

package/src/filters/helpers/backend/getBackendGroupValue.ts

@@ -1,7 +1,7 @@
+import { adaptDateGroupingProperty } from "../..";
 import { isEmpty } from "../../../general";
 import { isDateColumn } from "../../../qrvey/isDateColumn";
 import { IFProperty, IFSFilter } from "../../interfaces";
-import { arePropertiesDateP } from "../common";
 
 /**
  * Gets a group value for the backend logic structure
@@ -9,7 +9,8 @@ import { arePropertiesDateP } from "../common";
  * @returns a property
  */
 export function getBackendGroupValue(filter: IFSFilter): IFProperty {
-    if (!arePropertiesDateP(filter.column, filter.property) && isEmpty(filter.column.aggregate) && isDateColumn(filter.column as any) && filter.property != null) {
-        return filter.property;
+    if (isEmpty(filter.column.aggregate) && isDateColumn(filter.column as any) && filter.property != null) {
+        const property = adaptDateGroupingProperty(filter.property);
+        return property;
     }
 }

package/src/filters/helpers/backend/getBackendProperty.ts

@@ -2,7 +2,7 @@ import { COLUMN, COLUMN_PROPERTY } from "../../../constants";
 import { isEmpty } from "../../../general";
 import { isDateColumn } from "../../../qrvey/isDateColumn";
 import { IFProperty, IFSFilter } from "../../interfaces";
-import { arePropertiesDateP, isNullValidator } from "../common";
+import { isNullValidator } from "../common";
 
 /**
  * Gets a property for the logic structure
@@ -11,10 +11,8 @@ import { arePropertiesDateP, isNullValidator } from "../common";
  */
 export function getBackendProperty(filter: IFSFilter): IFProperty {
   if (isEmpty(filter.column.aggregate)) {
-    if (isNullValidator(filter.validator)) {
+    if (isNullValidator(filter.validator) || isDateColumn(filter.column as any)) {
       return undefined;
-    } else if (isDateColumn(filter.column as any)) {
-      return arePropertiesDateP(filter.column, filter.property) ? filter.property?.split('p&')[1] as IFProperty : undefined;
     } else if (filter.column.type === COLUMN.EXPRESSION && filter.property != null) {
         return undefined;
     } else if (filter.column.type === COLUMN.LOOKUP && filter.property === COLUMN_PROPERTY.LOOKUP_DISPLAY && filter.lookupDisplayIndex != null) {

package/src/filters/helpers/ui/getFilterPropertyLabel.ts

@@ -0,0 +1,11 @@
+import { IFSFilter, IFUFilter } from "../..";
+import { getPropertyLabel } from "../../..";
+
+/**
+     * Gets the label of the filter property
+     * @param filter The UI Filter
+     * @returns a string of the filter property label
+     */
+ export function getFilterPropertyLabel(filter: IFUFilter | IFSFilter): string {
+    return getPropertyLabel(filter.column as any, filter.property);
+}

package/src/filters/helpers/ui/index.ts

@@ -1,5 +1,6 @@
 export * from './excludeUIFiltersByAggregate';
 export * from './excludeUIFlatFiltersByScopes';
+export * from './getFilterPropertyLabel';
 export * from './getOutputFormatByColumn';
 export * from './getUIFlatFilterByParams';
 export * from './getUIFlatFiltersByParams';

package/src/general/array/filterNestedTree.ts

@@ -2,18 +2,27 @@ import { isEmpty } from "../mix";
 import { cloneDeep } from "../object/cloneDeep";
 
 /**
- * Filters a nested tree array by a custom condition on the las child node
+ * Filters a nested tree array by a custom condition on the last child node
+ * - If the given arguments are not valid, the function returns the first argument.
+ * - If the childArrKey is not matched in the object, the condition tries to resolve the filter anyway and returns an empty array.
+ * - If the condition is not fulfilled, the function returns a filtered array, probably a empty array inside of the child array
  * @param arr nested tree array
  * @param childArrKey property representing the children array on the nested tree
  * @param condition function callback that determines if the filter is applied on the last child node of the nested tree
  * @returns array filtered
  */
- export function filterNestedTree(arr: any[], childArrKey: string, condition: any): any[] {
-   if (isEmpty(arr)) return [];
+ export function filterNestedTree<T = any>(arr: T[] = [], childArrKey = '', condition: any = undefined): T[] {
+   if (!isValid(arr, childArrKey, condition)) return arr;
   
     return cloneDeep(arr).filter(obj => {
-      const hasChildArr = Array.isArray(obj[childArrKey]) && obj[childArrKey].length;
+      const hasChildArr = Array.isArray(obj[childArrKey]) && obj[childArrKey].length > 0;
       if (hasChildArr) obj[childArrKey] = filterNestedTree(obj[childArrKey], childArrKey, condition);
       return hasChildArr || condition(obj);
     });
 }
+
+function isValid<T = any>(arr: T[] = [], childArrKey = '', condition: any = undefined): boolean {
+  return (!isEmpty(arr) && Array.isArray(arr))
+  && (!isEmpty(childArrKey) && typeof childArrKey === 'string')
+  && (!isEmpty(condition) && typeof condition === "function");
+}

package/src/general/mix/getTag.ts

@@ -0,0 +1,12 @@
+/**
+ * Gets the `toStringTag` of `value`.
+ *
+ * @param {*} value The value to query.
+ * @returns {string} Returns the `toStringTag`.
+ */
+export function getTag(value: any): string {
+    if (value == null) {
+        return value === undefined ? '[object Undefined]' : '[object Null]';
+    }
+    return Object.prototype.toString.call(value);
+}

package/src/general/mix/index.ts

@@ -3,3 +3,4 @@ export * from './randomId';
 export * from './isNull';
 export * from './isEmpty';
 export * from './importScripts';
+export * from './getTag';

package/src/general/mix/isEmpty.ts

@@ -1,3 +1,6 @@
+import { getTag } from ".";
+import { isObject } from "..";
+
 /**
  * Validates if the given argument is empty
  * @param variable the given variable
@@ -5,11 +8,13 @@
  * @returns true: the given argument is empty; false: is not.
  */
 export function isEmpty<T = any>(variable: T, includeFalsy = false): boolean {
-    return typeof variable == 'undefined'
-        || variable == null
+    return variable == null
         || (typeof variable == 'number' && includeFalsy && (Number(variable) === 0 || Object.is(variable, -0) || isNaN(variable)))
-        || (typeof variable == 'string' && variable === "")
+        || (typeof variable == 'string' && variable.length === 0)
         || (typeof variable == 'boolean' && includeFalsy && variable === false)
         || (Array.isArray(variable) && variable.length === 0)
-        || (variable.constructor === Object && Object.entries(variable).length === 0);
+        || ((getTag(variable) === '[object Map]' || getTag(variable) === '[object Set]') && (variable as any | Set<T>).size === 0)
+        || (variable instanceof Date && isNaN(variable.valueOf()))
+        || (typeof variable === 'function' && Object.prototype.toString.call(variable).indexOf("Function") === 0)
+        || ((!(variable instanceof Date) && typeof variable !== 'function') && isObject(variable) && Object.entries(variable).length === 0);
 }

package/src/general/mix/isNull.ts

@@ -5,5 +5,5 @@
  * @returns {Boolean}
  */
 export function isNull(arg: any): boolean {
-    return arg === null || arg === undefined;
+    return arg == null;
 }

package/src/general/mix/randomId.ts

@@ -1,14 +1,31 @@
+import { isEmpty, isNull } from ".";
+
 /**
- * create random unique string
+ * Creates a random string
+ * - If the first given argument is different than a length number, the variable is replaced by a default number
+ * - If the optional second given argument is passed the random string is permutated.
  * @param {Number} length size of the generated string. Default 8
- * @return {String}
+ * @param {Array} exclude collection of strings that is going to be excluded of the random string.
+ * @return {String} Random string
  */
-export function randomId (_length = 8): string {
+export function randomId(length = 8, exclude: string[] = []): string {
+    if (typeof length !== 'number') length = 8;
+    if (isNull(exclude) || !Array.isArray(exclude)) exclude = [];
+    exclude = exclude.filter(e => typeof e === 'string');
+
     const charSet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_';
+    const blackList = [];
     let id = '';
-    for (let i = 0; i < 8; i++) {
-        const randPos = Math.floor(Math.random() * charSet.length);
-        id += charSet[randPos];
-    }
+    
+    do {
+        if (!isEmpty(id) && !blackList.includes(id)) blackList.push(id);
+        id = '';
+        for (let i = 0; i < length; i++) {
+            const randPos = Math.floor(Math.random() * charSet.length);
+            id += charSet[randPos];
+        }
+    } while (exclude.length > 0 && exclude.includes(id) && blackList.length < exclude.length);
+
+    if (exclude.length > 0 && blackList.length >= exclude.length) id = '';
     return id;
 }

package/src/general/mix/size.ts

@@ -1,10 +1,14 @@
+import { isEmpty } from ".";
+
 /**
- * get the length of an Array or String and also the number of first level attributes
- * in an Object.
- * For `null` or `undefined` argument the returned value will be 0.
- * @param {Any} obj 
- * @returns {Number}
+ * Gets the length of the given array.
+ * - Useful for Object, Array and string type.
+ * - For `null` or `undefined` or else argument the returned value will be 0.
+ * @param {Any} obj Any object-type variable
+ * @returns {Number} the size of the given variable
  */
 export function size(obj: any): number {
-    return Object.keys(obj || '').length;
+    if (isEmpty(obj)) return 0;
+
+    return Object.keys(obj).length;
 }

package/src/general/object/get.ts

@@ -26,7 +26,7 @@
  * _get({ item1: { item11: 'Hello Again' }, item2: {} }, ['item1', 'item11'])
  * @returns the resolved value.
  */
-export function _get(baseObject: any, path: string | string[], defaultValue?: any): any {
+export function _get<T = any>(baseObject: T, path: string | string[], defaultValue?: any): any {
   if (validateToReturnDefaultValue(baseObject, path)) return defaultValue;
 
   const keys = Array.isArray(path) ? path : path.replace(/(\[(\d)\])/g, '.$2').split('.').filter(k => k.length);

package/src/general/object/getAttribute.ts

@@ -1,6 +1,13 @@
 /**
- * search for properties in different case styles such as: lower, upper, camel and pascal
- * But for this, is required ask for a property in snake_case style
+ * Searchs for properties in different case styles such as: lower, upper, camel and pascal
+ * - To optimize the searching, it is required a key in a snake_case style
+ * - List of cases that do not match
+ * -- From lower to snake case
+ * -- From upper to snake case
+ * -- From lower to camel case
+ * -- From upper to camel case
+ * -- From lower to pascal case
+ * -- From upper to pascal case
  * @param {object} obj object to look for
  * @param {string} key String attribute in snake_case style
  * 
@@ -8,11 +15,42 @@
  * getAttribute(obj, 'snake_case') //it search for: obj.snake_case || obj.snakeCase || obj.SnakeCase || obj.snakecase || obj.SNAKECASE
  */
 
-export function getAttribute(obj: any, key: string) {
-    // getAttr: key should be lower_underscore_case
-    const camel = key.replace(/_(.)/g, (_, a) => a.toUpperCase());
-    const pascal = camel.replace(/(.)/, (_, a) => a.toUpperCase());
-    const lower = key.replace(/_/g, '');
-    const upper = lower.toUpperCase();
-    return obj[key] || obj[camel] || obj[pascal] || obj[lower] || obj[upper];
+import { isObject } from ".";
+import { isEmpty } from "..";
+
+export function getAttribute(obj: any, key: string): any {
+    if (!isValid(obj, key)) return;
+
+    const snake = getSnakeCase(key);
+    const camel = getCamelCase(snake);
+    const pascal = getPascalCase(camel);
+    const lower = getLowerCase(pascal);
+    const upper = getUpperCase(lower);
+
+    return obj[key] ?? obj[snake] ?? obj[camel] ?? obj[pascal] ?? obj[lower] ?? obj[upper];
+}
+
+function getSnakeCase(key: string): string {
+    return key.replace(/[A-Z]/g, (a, i) => i == 0 ? a.toLowerCase() : '_'+ a.toLowerCase());
+}
+
+function getCamelCase(key: string): string {
+    return key.replace(/(.)/, (_, a) => a.toLowerCase()).replace(/_(.)/g, (_, a) => a.toUpperCase());
+}
+
+function getPascalCase(key: string): string {
+    return key.replace(/(.)/, (_, a) => a.toUpperCase());
+}
+
+function getLowerCase(key: string): string {
+    return key.replace(/_/g, '').toLowerCase();
+}
+
+function getUpperCase(key: string): string {
+    return key.toUpperCase();
+}
+
+function isValid(obj: any, key: string): boolean {
+    return (!isEmpty(obj) && isObject(obj))
+    && (!isEmpty(key) && typeof key === 'string');
 }

package/src/general/object/hasProperty.ts

@@ -1,3 +1,6 @@
+import { isObject } from ".";
+import { isEmpty } from "..";
+
 /**
  * Use the hasOwnProperty in order to verify if the given property exists in the object.
  * 
@@ -14,7 +17,13 @@
  * const obj2 = { prop1: 'hello world' }
  * _hasProperty(ob1, prop2) // false
  */
+ export function _hasProperty(obj = {}, property: string | number = ''): boolean {
+    if (!isValid(obj, property)) return false;
 
- export function _hasProperty(obj = {}, property = ''): boolean {
     return Object.prototype.hasOwnProperty.call(obj, property);
 }
+
+function isValid(obj, property): boolean {
+    return !isEmpty(obj) && (isObject(obj) || Array.isArray(obj))
+    && !isEmpty(property) && (typeof property === 'string' || typeof property === 'number');
+}

package/src/general/object/index.ts

@@ -3,6 +3,7 @@ export * from './get';
 export * from './getAttribute';
 export * from './hasProperty';
 export * from './isObject';
+export * from './objectCopy';
 export * from './omit';
 export * from './pick';
 export * from './mapValues';

package/src/general/object/isObject.ts

@@ -1,8 +1,10 @@
+import { getTag } from "..";
+
 /**
  * Checks if the given argument is an object type
  * @param obj the variable to check
  * @returns True: It is an object; False: It is not.
  */
 export function isObject(obj: any): boolean {
-    return Object.prototype.toString.call(obj) === '[object Object]';
+    return obj === Object(obj) || getTag(obj) === '[object Object]';
 }

package/src/general/object/objectCopy.ts

@@ -0,0 +1,35 @@
+/**
+ * Created a new reference of the given argument
+ * @param entity The variable to be copied
+ * @param cache 
+ * @returns A new reference of the given argument
+ */
+export function objectCopy(entity, cache = new WeakMap()): any {
+    if (!isClonable(entity)) return entity;
+
+    if (cache.has(entity)) return cache.get(entity);
+
+    const c = new (entity as any).constructor;
+
+    if (c.name === 'Date') return new Date(entity as any) as any;
+
+    if (entity instanceof Map) {
+        entity.forEach((value, key) => c.set(objectCopy(key), objectCopy(value)));
+    }
+
+    if (entity instanceof Set) {
+        entity.forEach((value) => c.add(objectCopy(value)));
+    }
+
+    cache.set(entity, c);
+
+    return Object.assign(c,
+        ...Object.keys(entity).map((prop) => ({ [prop]: objectCopy(entity[prop], cache) }))
+    );
+}
+
+function isClonable(entity) {
+    const referenceTypes = ['Array', 'Object', 'Map', 'Set', 'Date'];
+    const entityName = entity && entity.constructor.name;
+    return referenceTypes.includes(entityName);
+}

package/src/general/string/capitalize.ts

@@ -1,8 +1,12 @@
+import { isEmpty } from "..";
+
 /**
- * Upper case teh first letter of a given text
+ * Upper case the first letter of a given text
  * @param {String} text 
- * @returns {String}
+ * @returns {String} a capitalized text
  */
-export function capitalize(text: string): string {
+export function capitalize(text = ''): string {
+    if (isEmpty(text) || typeof text !== 'string') return text;
+
     return text.toLowerCase().replace(/^\w/, c => c.toUpperCase());
 }

package/src/qrvey/getPropertyLabel.ts

@@ -0,0 +1,9 @@
+import { isDateColumn } from ".";
+import { COLUMN_PROPERTY, COLUMN_PROPERTY_VALUE, IQrveyColumn, isEmpty } from "..";
+
+export function getPropertyLabel(column: IQrveyColumn, property: COLUMN_PROPERTY): string {
+    let propertyLabel;
+    const propertyValues = COLUMN_PROPERTY_VALUE[isDateColumn(column) ? column.type + '-complete' : column.type];
+    if (!isEmpty(propertyValues)) propertyLabel = propertyValues.find(pValue => pValue.value === property)?.label;
+    return propertyLabel;
+}

package/src/qrvey/index.ts

@@ -1,3 +1,4 @@
 export * from './getColumnsLabel';
+export * from './getPropertyLabel';
 export * from './isDateColumn';
 export * from './isComplexColumn';