@adaptabletools/adaptable 16.2.4 → 17.0.0-canary.0

package/src/Utilities/ExpressionFunctions/scalarExpressionFunctions.js

@@ -1,26 +1,22 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.scalarExpressionFunctionNames = exports.scalarExpressionFunctions = void 0;
-const tslib_1 = require("tslib");
-const ExpressionEvaluationError_1 = require("../../parser/src/ExpressionEvaluationError");
-const parseISO_1 = tslib_1.__importDefault(require("date-fns/parseISO"));
-const startOfDay_1 = tslib_1.__importDefault(require("date-fns/startOfDay"));
-const startOfWeek_1 = tslib_1.__importDefault(require("date-fns/startOfWeek"));
-const startOfMonth_1 = tslib_1.__importDefault(require("date-fns/startOfMonth"));
-const startOfYear_1 = tslib_1.__importDefault(require("date-fns/startOfYear"));
-const addDays_1 = tslib_1.__importDefault(require("date-fns/addDays"));
-const addWeeks_1 = tslib_1.__importDefault(require("date-fns/addWeeks"));
-const addMonths_1 = tslib_1.__importDefault(require("date-fns/addMonths"));
-const addYears_1 = tslib_1.__importDefault(require("date-fns/addYears"));
-const differenceInDays_1 = tslib_1.__importDefault(require("date-fns/differenceInDays"));
-const differenceInWeeks_1 = tslib_1.__importDefault(require("date-fns/differenceInWeeks"));
-const differenceInMonths_1 = tslib_1.__importDefault(require("date-fns/differenceInMonths"));
-const differenceInYears_1 = tslib_1.__importDefault(require("date-fns/differenceInYears"));
-const expressionFunctionUtils_1 = require("./expressionFunctionUtils");
-const dateUtils_1 = require("./dateUtils");
-const StringExtensions_1 = tslib_1.__importDefault(require("../Extensions/StringExtensions"));
-const TypeExtensions_1 = require("../Extensions/TypeExtensions");
-const src_1 = require("../../parser/src");
+import { ExpressionEvaluationError } from '../../parser/src/ExpressionEvaluationError';
+import parseISO from 'date-fns/parseISO';
+import startOfDay from 'date-fns/startOfDay';
+import startOfWeek from 'date-fns/startOfWeek';
+import startOfMonth from 'date-fns/startOfMonth';
+import startOfYear from 'date-fns/startOfYear';
+import addDays from 'date-fns/addDays';
+import addWeeks from 'date-fns/addWeeks';
+import addMonths from 'date-fns/addMonths';
+import addYears from 'date-fns/addYears';
+import differenceInDays from 'date-fns/differenceInDays';
+import differenceInWeeks from 'date-fns/differenceInWeeks';
+import differenceInMonths from 'date-fns/differenceInMonths';
+import differenceInYears from 'date-fns/differenceInYears';
+import { evaluateExpressionNode, isTextSearchCaseInsensitive, } from './expressionFunctionUtils';
+import { normalizeDateParams } from './dateUtils';
+import StringExtensions from '../Extensions/StringExtensions';
+import { getTypedKeys } from '../Extensions/TypeExtensions';
+import { evaluate } from '../../parser/src';
 // useful for unary operators which expect a list of arguments
 // we extract the provided array elements into a list
 const flattenArguments = (values) => {
@@ -38,12 +34,12 @@ const sanitizeNumericResult = (value) => {
     }
     return value;
 };
-exports.scalarExpressionFunctions = {
+export const scalarExpressionFunctions = {
     VAR: {
         handler(args, context) {
             const [functionName, ...optionalArgs] = args;
-            if (StringExtensions_1.default.IsNullOrEmpty(functionName)) {
-                throw new ExpressionEvaluationError_1.ExpressionEvaluationError('VAR', 'should have a name');
+            if (StringExtensions.IsNullOrEmpty(functionName)) {
+                throw new ExpressionEvaluationError('VAR', 'should have a name');
             }
             return context.evaluateCustomQueryVariable(functionName, optionalArgs);
         },
@@ -59,10 +55,10 @@ exports.scalarExpressionFunctions = {
             const columnId = args[0];
             const column = (_a = context.adaptableApi) === null || _a === void 0 ? void 0 : _a.columnApi.getColumnWithColumnId(columnId);
             if (!column) {
-                throw new ExpressionEvaluationError_1.ExpressionEvaluationError('COL', `Column name "${columnId}" is not found`);
+                throw new ExpressionEvaluationError('COL', `Column name "${columnId}" is not found`);
             }
             if (!column.queryable) {
-                throw new ExpressionEvaluationError_1.ExpressionEvaluationError('COL', `Column name "${columnId}" is not queryable`);
+                throw new ExpressionEvaluationError('COL', `Column name "${columnId}" is not queryable`);
             }
             return (_b = context.adaptableApi) === null || _b === void 0 ? void 0 : _b.gridApi.getNormalisedValueFromRowNode(context.node, columnId);
         },
@@ -76,12 +72,12 @@ exports.scalarExpressionFunctions = {
         handler(args, context) {
             var _a, _b;
             const namedQueryName = args[0];
-            if (StringExtensions_1.default.IsNullOrEmpty(namedQueryName)) {
+            if (StringExtensions.IsNullOrEmpty(namedQueryName)) {
                 return false;
             }
-            const namedQuery = (_a = context.adaptableApi) === null || _a === void 0 ? void 0 : _a.queryApi.getNamedQueryByName(namedQueryName);
+            const namedQuery = (_a = context.adaptableApi) === null || _a === void 0 ? void 0 : _a.namedQueryApi.getNamedQueryByName(namedQueryName);
             if (!namedQuery) {
-                throw new ExpressionEvaluationError_1.ExpressionEvaluationError('QUERY', `Named Query with name ${namedQueryName} not found!`);
+                throw new ExpressionEvaluationError('QUERY', `Named Query with name ${namedQueryName} not found!`);
             }
             // add query to call stack
             if (!context.namedQueryCallStack) {
@@ -93,9 +89,9 @@ exports.scalarExpressionFunctions = {
             const lastIndex = context.namedQueryCallStack.lastIndexOf(namedQueryName);
             if (firstIndex !== lastIndex) {
                 const cycle = context.namedQueryCallStack.slice(firstIndex, lastIndex + 1);
-                throw new ExpressionEvaluationError_1.ExpressionEvaluationError(`${namedQueryName}`, ` contains a circular reference: ${cycle.join('  ->  ')}`);
+                throw new ExpressionEvaluationError(`${namedQueryName}`, ` contains a circular reference: ${cycle.join('  ->  ')}`);
             }
-            const queryEvaluationResult = (0, src_1.evaluate)(namedQuery.BooleanExpression, context);
+            const queryEvaluationResult = evaluate(namedQuery.BooleanExpression, context);
             // remove query name from callstack
             (_b = context.namedQueryCallStack) === null || _b === void 0 ? void 0 : _b.pop();
             return queryEvaluationResult;
@@ -308,20 +304,20 @@ exports.scalarExpressionFunctions = {
         handler([expressionValueNode, whenThenListNodes, defaultValueNode], context) {
             const caseExpressionValue = expressionValueNode != undefined
                 ? // CASE matches the first WHEN statement with the provided expression value
-                    (0, expressionFunctionUtils_1.evaluateExpressionNode)(expressionValueNode, context)
+                    evaluateExpressionNode(expressionValueNode, context)
                 : // otherwise it returns the first WHEN statement evaluated to TRUE
                     true;
             const matchingWhen = whenThenListNodes.find((whenThenStatement) => {
-                const whenValue = (0, expressionFunctionUtils_1.evaluateExpressionNode)(whenThenStatement.WHEN, context);
+                const whenValue = evaluateExpressionNode(whenThenStatement.WHEN, context);
                 return whenValue === caseExpressionValue;
             });
             if (!matchingWhen) {
                 if (defaultValueNode) {
-                    return (0, expressionFunctionUtils_1.evaluateExpressionNode)(defaultValueNode, context);
+                    return evaluateExpressionNode(defaultValueNode, context);
                 }
                 return;
             }
-            const matchingThen = (0, expressionFunctionUtils_1.evaluateExpressionNode)(matchingWhen.THEN, context);
+            const matchingThen = evaluateExpressionNode(matchingWhen.THEN, context);
             return matchingThen;
         },
         isHiddenFromMenu: true,
@@ -354,7 +350,7 @@ exports.scalarExpressionFunctions = {
     },
     DATE: {
         handler(args) {
-            return (0, parseISO_1.default)(args[0]);
+            return parseISO(args[0]);
         },
         description: 'Returns a new date by parsing the given string in ISO 8601 format',
         signatures: [
@@ -379,7 +375,7 @@ exports.scalarExpressionFunctions = {
     },
     TODAY: {
         handler() {
-            return (0, startOfDay_1.default)(new Date());
+            return startOfDay(new Date());
         },
         description: 'Returns the current day',
         signatures: ['TODAY()'],
@@ -389,7 +385,7 @@ exports.scalarExpressionFunctions = {
     },
     DAY: {
         handler(args) {
-            return (0, startOfDay_1.default)(args[0]);
+            return startOfDay(args[0]);
         },
         description: 'Returns the day from a date',
         signatures: ['DAY(input: date)'],
@@ -399,7 +395,7 @@ exports.scalarExpressionFunctions = {
     },
     WEEK: {
         handler(args) {
-            return (0, startOfWeek_1.default)(args[0]);
+            return startOfWeek(args[0]);
         },
         description: 'Returns the week from a date',
         signatures: ['WEEK(input: date)'],
@@ -409,7 +405,7 @@ exports.scalarExpressionFunctions = {
     },
     MONTH: {
         handler(args) {
-            return (0, startOfMonth_1.default)(args[0]);
+            return startOfMonth(args[0]);
         },
         description: 'Returns the month from a date',
         signatures: ['MONTH(input: date)'],
@@ -419,7 +415,7 @@ exports.scalarExpressionFunctions = {
     },
     YEAR: {
         handler(args) {
-            return (0, startOfYear_1.default)(args[0]);
+            return startOfYear(args[0]);
         },
         description: 'Returns the year from a date',
         signatures: ['YEAR(input: date)'],
@@ -429,7 +425,7 @@ exports.scalarExpressionFunctions = {
     },
     ADD_DAYS: {
         handler(args) {
-            return (0, addDays_1.default)(args[0], args[1]);
+            return addDays(args[0], args[1]);
         },
         description: 'Returns a date based on input data and days to add',
         signatures: ['ADD_DAYS(input: date, days: number)'],
@@ -439,7 +435,7 @@ exports.scalarExpressionFunctions = {
     },
     ADD_WEEKS: {
         handler(args) {
-            return (0, addWeeks_1.default)(args[0], args[1]);
+            return addWeeks(args[0], args[1]);
         },
         description: 'Returns a date based on input data and weeks to add',
         signatures: ['ADD_WEEKS(input: date, weeks: number)'],
@@ -449,7 +445,7 @@ exports.scalarExpressionFunctions = {
     },
     ADD_MONTHS: {
         handler(args) {
-            return (0, addMonths_1.default)(args[0], args[1]);
+            return addMonths(args[0], args[1]);
         },
         description: 'Returns a date based on input data and months to add',
         signatures: ['ADD_MONTHS(input: date, months: number)'],
@@ -459,7 +455,7 @@ exports.scalarExpressionFunctions = {
     },
     ADD_YEARS: {
         handler(args) {
-            return (0, addYears_1.default)(args[0], args[1]);
+            return addYears(args[0], args[1]);
         },
         description: 'Returns a date based on input data and years to add',
         signatures: ['ADD_YEARS(input: date, years: number)'],
@@ -469,8 +465,8 @@ exports.scalarExpressionFunctions = {
     },
     DIFF_DAYS: {
         handler(args) {
-            const [first, second] = (0, dateUtils_1.normalizeDateParams)(args);
-            const result = (0, differenceInDays_1.default)(first, second);
+            const [first, second] = normalizeDateParams(args);
+            const result = differenceInDays(first, second);
             return sanitizeNumericResult(result);
         },
         description: 'Returns the difference in days between 2 dates',
@@ -481,8 +477,8 @@ exports.scalarExpressionFunctions = {
     },
     DIFF_WEEKS: {
         handler(args) {
-            const [first, second] = (0, dateUtils_1.normalizeDateParams)(args);
-            const result = (0, differenceInWeeks_1.default)(first, second);
+            const [first, second] = normalizeDateParams(args);
+            const result = differenceInWeeks(first, second);
             return sanitizeNumericResult(result);
         },
         description: 'Returns the difference in weeks between 2 dates',
@@ -493,8 +489,8 @@ exports.scalarExpressionFunctions = {
     },
     DIFF_MONTHS: {
         handler(args) {
-            const [first, second] = (0, dateUtils_1.normalizeDateParams)(args);
-            const result = (0, differenceInMonths_1.default)(first, second);
+            const [first, second] = normalizeDateParams(args);
+            const result = differenceInMonths(first, second);
             return sanitizeNumericResult(result);
         },
         description: 'Returns the difference in months between 2 dates',
@@ -505,8 +501,8 @@ exports.scalarExpressionFunctions = {
     },
     DIFF_YEARS: {
         handler(args) {
-            const [first, second] = (0, dateUtils_1.normalizeDateParams)(args);
-            const result = (0, differenceInYears_1.default)(first, second);
+            const [first, second] = normalizeDateParams(args);
+            const result = differenceInYears(first, second);
             return sanitizeNumericResult(result);
         },
         description: 'Returns the difference in years between 2 dates',
@@ -557,7 +553,7 @@ exports.scalarExpressionFunctions = {
     },
     REPLACE: {
         handler(args, context) {
-            if ((0, expressionFunctionUtils_1.isTextSearchCaseInsensitive)(context)) {
+            if (isTextSearchCaseInsensitive(context)) {
                 return String(args[0]).replace(new RegExp(args[1], 'ig'), args[2]);
             }
             else {
@@ -581,4 +577,4 @@ exports.scalarExpressionFunctions = {
         returnType: 'string',
     },
 };
-exports.scalarExpressionFunctionNames = (0, TypeExtensions_1.getTypedKeys)(exports.scalarExpressionFunctions);
+export const scalarExpressionFunctionNames = getTypedKeys(scalarExpressionFunctions);

package/src/Utilities/Extensions/ArrayExtensions.js

@@ -1,33 +1,25 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ArrayExtensions = exports.createCommaSeparatedString = exports.groupArrayBy = exports.sortCellValueArrayDates = exports.sortCellValueArrayNumeric = exports.sortCellValueArray = exports.sortArray = exports.sortArrayWithProperty = exports.areArraysEqualWithOrderandProperties = exports.areArraysEqualWithOrder = exports.areArraysNotEqual = exports.areArraysEqual = exports.moveArray = exports.hasItemsOfCount = exports.hasOneItem = exports.HasSingleEmptyValue = exports.IsNotNullOrEmptyNorContainsSingleEmptyValue = exports.IsNullOrEmptyOrContainsSingleEmptyValue = exports.IsNotNullOrEmpty = exports.IsNullOrEmpty = exports.IsNotEmpty = exports.IsEmpty = exports.IsNotNull = exports.IsNull = exports.RetrieveDistinct = exports.NotContainsItem = exports.ContainsAnyItem = exports.ContainsItem = exports.AddItem = exports.NotCorrectLength = exports.CorrectLength = exports.GetLength = void 0;
-const Enums_1 = require("../../PredefinedConfig/Common/Enums");
-function GetLength(arrayToCheck) {
+import { SortOrder } from '../../PredefinedConfig/Common/Enums';
+export function GetLength(arrayToCheck) {
     return IsNotNull(arrayToCheck) ? arrayToCheck.length : 0;
 }
-exports.GetLength = GetLength;
-function CorrectLength(arrayToCheck, requiredLength) {
+export function CorrectLength(arrayToCheck, requiredLength) {
     return GetLength(arrayToCheck) == requiredLength;
 }
-exports.CorrectLength = CorrectLength;
-function NotCorrectLength(arrayToCheck, requiredLength) {
+export function NotCorrectLength(arrayToCheck, requiredLength) {
     return !CorrectLength(arrayToCheck, requiredLength);
 }
-exports.NotCorrectLength = NotCorrectLength;
-function AddItem(array, itemToAdd) {
+export function AddItem(array, itemToAdd) {
     if (NotContainsItem(array, itemToAdd)) {
         array.push(itemToAdd);
     }
 }
-exports.AddItem = AddItem;
-function ContainsItem(array, itemToCheck) {
+export function ContainsItem(array, itemToCheck) {
     if (array == null) {
         return false;
     }
     return array.indexOf(itemToCheck) > -1;
 }
-exports.ContainsItem = ContainsItem;
-function ContainsAnyItem(array, itemsToCheck) {
+export function ContainsAnyItem(array, itemsToCheck) {
     if (array == null) {
         return false;
     }
@@ -41,40 +33,31 @@ function ContainsAnyItem(array, itemsToCheck) {
     });
     return foundItem;
 }
-exports.ContainsAnyItem = ContainsAnyItem;
-function NotContainsItem(array, itemToCheck) {
+export function NotContainsItem(array, itemToCheck) {
     return !ContainsItem(array, itemToCheck);
 }
-exports.NotContainsItem = NotContainsItem;
-function RetrieveDistinct(array) {
+export function RetrieveDistinct(array) {
     return Array.from(new Set(array.map((item) => item)));
 }
-exports.RetrieveDistinct = RetrieveDistinct;
-function IsNull(arrayToCheck) {
+export function IsNull(arrayToCheck) {
     return arrayToCheck == null || arrayToCheck == undefined;
 }
-exports.IsNull = IsNull;
-function IsNotNull(arrayToCheck) {
+export function IsNotNull(arrayToCheck) {
     return !IsNull(arrayToCheck);
 }
-exports.IsNotNull = IsNotNull;
-function IsEmpty(arrayToCheck) {
+export function IsEmpty(arrayToCheck) {
     return (arrayToCheck === null || arrayToCheck === void 0 ? void 0 : arrayToCheck.length) == 0;
 }
-exports.IsEmpty = IsEmpty;
-function IsNotEmpty(arrayToCheck) {
+export function IsNotEmpty(arrayToCheck) {
     return !IsEmpty(arrayToCheck);
 }
-exports.IsNotEmpty = IsNotEmpty;
-function IsNullOrEmpty(arrayToCheck) {
+export function IsNullOrEmpty(arrayToCheck) {
     return IsNull(arrayToCheck) || IsEmpty(arrayToCheck);
 }
-exports.IsNullOrEmpty = IsNullOrEmpty;
-function IsNotNullOrEmpty(arrayToCheck) {
+export function IsNotNullOrEmpty(arrayToCheck) {
     return IsNotNull(arrayToCheck) && IsNotEmpty(arrayToCheck);
 }
-exports.IsNotNullOrEmpty = IsNotNullOrEmpty;
-function IsNullOrEmptyOrContainsSingleEmptyValue(arrayToCheck) {
+export function IsNullOrEmptyOrContainsSingleEmptyValue(arrayToCheck) {
     if (IsNullOrEmpty(arrayToCheck)) {
         return true;
     }
@@ -83,32 +66,26 @@ function IsNullOrEmptyOrContainsSingleEmptyValue(arrayToCheck) {
     }
     return false;
 }
-exports.IsNullOrEmptyOrContainsSingleEmptyValue = IsNullOrEmptyOrContainsSingleEmptyValue;
-function IsNotNullOrEmptyNorContainsSingleEmptyValue(arrayToCheck) {
+export function IsNotNullOrEmptyNorContainsSingleEmptyValue(arrayToCheck) {
     return !IsNullOrEmptyOrContainsSingleEmptyValue(arrayToCheck);
 }
-exports.IsNotNullOrEmptyNorContainsSingleEmptyValue = IsNotNullOrEmptyNorContainsSingleEmptyValue;
-function HasSingleEmptyValue(arrayToCheck) {
+export function HasSingleEmptyValue(arrayToCheck) {
     if (arrayToCheck.length == 1 && arrayToCheck[0] == '') {
         return true;
     }
     return false;
 }
-exports.HasSingleEmptyValue = HasSingleEmptyValue;
-function hasOneItem(arrayToCheck) {
+export function hasOneItem(arrayToCheck) {
     return hasItemsOfCount(arrayToCheck, 1);
 }
-exports.hasOneItem = hasOneItem;
-function hasItemsOfCount(arrayToCheck, numberOfItems) {
+export function hasItemsOfCount(arrayToCheck, numberOfItems) {
     return arrayToCheck.length == numberOfItems;
 }
-exports.hasItemsOfCount = hasItemsOfCount;
-function moveArray(array, from, to) {
+export function moveArray(array, from, to) {
     array.splice(to, 0, array.splice(from, 1)[0]);
 }
-exports.moveArray = moveArray;
 //This deliberately only checks contents equality and not positional so [1, 2, 3]== [1, 3, 2]
-function areArraysEqual(arr1, arr2) {
+export function areArraysEqual(arr1, arr2) {
     if (IsNullOrEmpty(arr1) && IsNotNullOrEmpty(arr2)) {
         return false;
     }
@@ -120,12 +97,10 @@ function areArraysEqual(arr1, arr2) {
     }
     return arr1.every((x) => arr2.indexOf(x) != -1);
 }
-exports.areArraysEqual = areArraysEqual;
-function areArraysNotEqual(arr1, arr2) {
+export function areArraysNotEqual(arr1, arr2) {
     return !areArraysEqual(arr1, arr2);
 }
-exports.areArraysNotEqual = areArraysNotEqual;
-function areArraysEqualWithOrder(arr1, arr2) {
+export function areArraysEqualWithOrder(arr1, arr2) {
     if (arr1 == null) {
         return true;
     }
@@ -134,8 +109,7 @@ function areArraysEqualWithOrder(arr1, arr2) {
     }
     return arr1.every((x, index) => arr2.indexOf(x) == index);
 }
-exports.areArraysEqualWithOrder = areArraysEqualWithOrder;
-function areArraysEqualWithOrderandProperties(value, other) {
+export function areArraysEqualWithOrderandProperties(value, other) {
     const type = Object.prototype.toString.call(value);
     // If the two objects are not the same type, return false
     if (type !== Object.prototype.toString.call(other)) {
@@ -201,12 +175,11 @@ function areArraysEqualWithOrderandProperties(value, other) {
     // If nothing failed, return true
     return true;
 }
-exports.areArraysEqualWithOrderandProperties = areArraysEqualWithOrderandProperties;
-function sortArrayWithProperty(sortOrder, values, sortProperty) {
+export function sortArrayWithProperty(sortOrder, values, sortProperty) {
     if (sortProperty) {
         let newValues = [].concat(values);
         let direction = 1;
-        if (sortOrder == Enums_1.SortOrder.Desc) {
+        if (sortOrder == SortOrder.Desc) {
             direction = -1;
         }
         return newValues.sort((a, b) => {
@@ -228,21 +201,18 @@ function sortArrayWithProperty(sortOrder, values, sortProperty) {
         return sortArray(values, sortOrder);
     }
 }
-exports.sortArrayWithProperty = sortArrayWithProperty;
-function sortArray(values, sortOrder = Enums_1.SortOrder.Asc) {
+export function sortArray(values, sortOrder = SortOrder.Asc) {
     const newValues = [].concat(values);
-    const direction = sortOrder == Enums_1.SortOrder.Asc ? 1 : -1;
+    const direction = sortOrder == SortOrder.Asc ? 1 : -1;
     return newValues.sort((a, b) => (a < b ? -1 * direction : a > b ? 1 * direction : 0));
 }
-exports.sortArray = sortArray;
-function sortCellValueArray(cellValues, sortOrder = Enums_1.SortOrder.Asc) {
+export function sortCellValueArray(cellValues, sortOrder = SortOrder.Asc) {
     const newValues = [].concat(cellValues);
-    const direction = sortOrder == Enums_1.SortOrder.Asc ? 1 : -1;
+    const direction = sortOrder == SortOrder.Asc ? 1 : -1;
     return newValues.sort((a, b) => a.rawValue < b.rawValue ? -1 * direction : a.rawValue > b.rawValue ? 1 * direction : 0);
 }
-exports.sortCellValueArray = sortCellValueArray;
-function sortCellValueArrayNumeric(cellValues, sortOrder = Enums_1.SortOrder.Asc) {
-    const direction = sortOrder == Enums_1.SortOrder.Asc ? 1 : -1;
+export function sortCellValueArrayNumeric(cellValues, sortOrder = SortOrder.Asc) {
+    const direction = sortOrder == SortOrder.Asc ? 1 : -1;
     const newValues = [].concat(cellValues);
     return newValues.sort((a, b) => {
         const valueAAsNumber = Number(a.rawValue);
@@ -260,17 +230,15 @@ function sortCellValueArrayNumeric(cellValues, sortOrder = Enums_1.SortOrder.Asc
                 : 0;
     });
 }
-exports.sortCellValueArrayNumeric = sortCellValueArrayNumeric;
-function sortCellValueArrayDates(cellValues, sortOrder = Enums_1.SortOrder.Asc) {
+export function sortCellValueArrayDates(cellValues, sortOrder = SortOrder.Asc) {
     cellValues.sort((a, b) => {
-        return sortOrder == Enums_1.SortOrder.Asc
+        return sortOrder == SortOrder.Asc
             ? +new Date(a.rawValue) - +new Date(b.rawValue)
             : +new Date(b.rawValue) - +new Date(a.rawValue);
     });
     return cellValues;
 }
-exports.sortCellValueArrayDates = sortCellValueArrayDates;
-function groupArrayBy(array, prop) {
+export function groupArrayBy(array, prop) {
     return array.reduce((acc, item) => {
         let key = item[prop];
         acc[key] = acc[key] || [];
@@ -278,12 +246,10 @@ function groupArrayBy(array, prop) {
         return acc;
     }, {});
 }
-exports.groupArrayBy = groupArrayBy;
-function createCommaSeparatedString(values) {
+export function createCommaSeparatedString(values) {
     return values.join(', ');
 }
-exports.createCommaSeparatedString = createCommaSeparatedString;
-exports.ArrayExtensions = {
+export const ArrayExtensions = {
     GetLength,
     CorrectLength,
     NotCorrectLength,
@@ -316,4 +282,4 @@ exports.ArrayExtensions = {
     sortArrayWithProperty,
     createCommaSeparatedString,
 };
-exports.default = exports.ArrayExtensions;
+export default ArrayExtensions;

package/src/Utilities/Extensions/EnumExtensions.js

@@ -1,41 +1,34 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EnumExtensions = exports.getCssFontSizeFromFontSizeEnum = exports.getObjValues = exports.getValues = exports.getNames = void 0;
-const Enums_1 = require("../../PredefinedConfig/Common/Enums");
+import { FontSize } from '../../PredefinedConfig/Common/Enums';
 // export function getNamesAndValues<T extends number>(e: any) {
 //     return EnumExtensions.getNames(e).map(n => ({ name: n, value: e[n] as T }));
 // }
-function getNames(e) {
-    return exports.EnumExtensions.getObjValues(e).filter((v) => typeof v === 'string');
+export function getNames(e) {
+    return EnumExtensions.getObjValues(e).filter((v) => typeof v === 'string');
 }
-exports.getNames = getNames;
-function getValues(e) {
-    return exports.EnumExtensions.getObjValues(e).filter((v) => typeof v === 'number');
+export function getValues(e) {
+    return EnumExtensions.getObjValues(e).filter((v) => typeof v === 'number');
 }
-exports.getValues = getValues;
-function getObjValues(e) {
+export function getObjValues(e) {
     return Object.keys(e).map((k) => e[k]);
 }
-exports.getObjValues = getObjValues;
-function getCssFontSizeFromFontSizeEnum(fontSize) {
+export function getCssFontSizeFromFontSizeEnum(fontSize) {
     switch (fontSize) {
-        case Enums_1.FontSize.XLarge:
+        case FontSize.XLarge:
             return 'x-large';
-        case Enums_1.FontSize.Large:
+        case FontSize.Large:
             return 'large';
-        case Enums_1.FontSize.Medium:
+        case FontSize.Medium:
             return 'medium';
-        case Enums_1.FontSize.Small:
+        case FontSize.Small:
             return 'small';
-        case Enums_1.FontSize.XSmall:
+        case FontSize.XSmall:
             return 'x-small';
     }
 }
-exports.getCssFontSizeFromFontSizeEnum = getCssFontSizeFromFontSizeEnum;
-exports.EnumExtensions = {
+export const EnumExtensions = {
     getNames,
     getValues,
     getObjValues,
     getCssFontSizeFromFontSizeEnum,
 };
-exports.default = exports.EnumExtensions;
+export default EnumExtensions;

package/src/Utilities/Extensions/NumberExtensions.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NumberExtensions = exports.WrapInParentheses = exports.abbreviateNumber = void 0;
-function abbreviateNumber(numberToAbbreviate) {
+export function abbreviateNumber(numberToAbbreviate) {
     let str = '';
     if (numberToAbbreviate >= 1000000000) {
         str = (numberToAbbreviate / 1000000000).toFixed(1) + 'B';
@@ -17,13 +14,11 @@ function abbreviateNumber(numberToAbbreviate) {
     }
     return str;
 }
-exports.abbreviateNumber = abbreviateNumber;
-function WrapInParentheses(numberToWrap) {
+export function WrapInParentheses(numberToWrap) {
     return ' (' + numberToWrap + ')';
 }
-exports.WrapInParentheses = WrapInParentheses;
-exports.NumberExtensions = {
+export const NumberExtensions = {
     abbreviateNumber,
     WrapInParentheses,
 };
-exports.default = exports.NumberExtensions;
+export default NumberExtensions;

package/src/Utilities/Extensions/ObjectExtensions.d.ts

@@ -9,3 +9,4 @@
  */
 export declare function setInPath<T>(obj: any, path: string[], value: any): T;
 export declare function isObjectEmpty(obj?: any): boolean;
+export declare const deepClone: (obj: any) => any;

package/src/Utilities/Extensions/ObjectExtensions.js

@@ -1,6 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isObjectEmpty = exports.setInPath = void 0;
 /**
  * Returns a new object with the property updated.
  * The property is identified by the path.
@@ -10,15 +7,16 @@ exports.isObjectEmpty = exports.setInPath = void 0;
  * @param value new property value
  * @returns
  */
-function setInPath(obj, path, value) {
+export function setInPath(obj, path, value) {
     var _a;
     if (path.length === 1) {
         return Object.assign(Object.assign({}, obj), { [path[0]]: value });
     }
     return Object.assign(Object.assign({}, obj), { [path[0]]: setInPath((_a = obj === null || obj === void 0 ? void 0 : obj[path[0]]) !== null && _a !== void 0 ? _a : {}, path.slice(1), value) });
 }
-exports.setInPath = setInPath;
-function isObjectEmpty(obj) {
+export function isObjectEmpty(obj) {
     return !obj || Object.keys(obj).length === 0;
 }
-exports.isObjectEmpty = isObjectEmpty;
+export const deepClone = (obj) => {
+    return JSON.parse(JSON.stringify(obj));
+};