@adaptabletools/adaptable 17.0.0-canary.4 → 17.0.0-canary.6

package/src/Utilities/ExpressionFunctions/scalarExpressionFunctions.js

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

package/src/Utilities/Extensions/ArrayExtensions.js

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

package/src/Utilities/Extensions/EnumExtensions.js

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

package/src/Utilities/Extensions/NumberExtensions.js

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

package/src/Utilities/Extensions/ObjectExtensions.js

@@ -1,3 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deepClone = exports.isObjectEmpty = exports.setInPath = void 0;
 /**
  * Returns a new object with the property updated.
  * The property is identified by the path.
@@ -7,16 +10,19 @@
  * @param value new property value
  * @returns
  */
-export function setInPath(obj, path, value) {
+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) });
 }
-export function isObjectEmpty(obj) {
+exports.setInPath = setInPath;
+function isObjectEmpty(obj) {
     return !obj || Object.keys(obj).length === 0;
 }
-export const deepClone = (obj) => {
+exports.isObjectEmpty = isObjectEmpty;
+const deepClone = (obj) => {
     return JSON.parse(JSON.stringify(obj));
 };
+exports.deepClone = deepClone;