@adaptabletools/adaptable-cjs 17.0.0-canary.1

package/src/Utilities/Extensions/ArrayExtensions.js

@@ -0,0 +1,319 @@
+"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;
+}
+exports.GetLength = GetLength;
+function CorrectLength(arrayToCheck, requiredLength) {
+    return GetLength(arrayToCheck) == requiredLength;
+}
+exports.CorrectLength = CorrectLength;
+function NotCorrectLength(arrayToCheck, requiredLength) {
+    return !CorrectLength(arrayToCheck, requiredLength);
+}
+exports.NotCorrectLength = NotCorrectLength;
+function AddItem(array, itemToAdd) {
+    if (NotContainsItem(array, itemToAdd)) {
+        array.push(itemToAdd);
+    }
+}
+exports.AddItem = AddItem;
+function ContainsItem(array, itemToCheck) {
+    if (array == null) {
+        return false;
+    }
+    return array.indexOf(itemToCheck) > -1;
+}
+exports.ContainsItem = ContainsItem;
+function ContainsAnyItem(array, itemsToCheck) {
+    if (array == null) {
+        return false;
+    }
+    let foundItem = false;
+    itemsToCheck.forEach((item) => {
+        if (!foundItem) {
+            if (ContainsItem(array, item)) {
+                foundItem = true;
+            }
+        }
+    });
+    return foundItem;
+}
+exports.ContainsAnyItem = ContainsAnyItem;
+function NotContainsItem(array, itemToCheck) {
+    return !ContainsItem(array, itemToCheck);
+}
+exports.NotContainsItem = NotContainsItem;
+function RetrieveDistinct(array) {
+    return Array.from(new Set(array.map((item) => item)));
+}
+exports.RetrieveDistinct = RetrieveDistinct;
+function IsNull(arrayToCheck) {
+    return arrayToCheck == null || arrayToCheck == undefined;
+}
+exports.IsNull = IsNull;
+function IsNotNull(arrayToCheck) {
+    return !IsNull(arrayToCheck);
+}
+exports.IsNotNull = IsNotNull;
+function IsEmpty(arrayToCheck) {
+    return (arrayToCheck === null || arrayToCheck === void 0 ? void 0 : arrayToCheck.length) == 0;
+}
+exports.IsEmpty = IsEmpty;
+function IsNotEmpty(arrayToCheck) {
+    return !IsEmpty(arrayToCheck);
+}
+exports.IsNotEmpty = IsNotEmpty;
+function IsNullOrEmpty(arrayToCheck) {
+    return IsNull(arrayToCheck) || IsEmpty(arrayToCheck);
+}
+exports.IsNullOrEmpty = IsNullOrEmpty;
+function IsNotNullOrEmpty(arrayToCheck) {
+    return IsNotNull(arrayToCheck) && IsNotEmpty(arrayToCheck);
+}
+exports.IsNotNullOrEmpty = IsNotNullOrEmpty;
+function IsNullOrEmptyOrContainsSingleEmptyValue(arrayToCheck) {
+    if (IsNullOrEmpty(arrayToCheck)) {
+        return true;
+    }
+    if (HasSingleEmptyValue(arrayToCheck)) {
+        return true;
+    }
+    return false;
+}
+exports.IsNullOrEmptyOrContainsSingleEmptyValue = IsNullOrEmptyOrContainsSingleEmptyValue;
+function IsNotNullOrEmptyNorContainsSingleEmptyValue(arrayToCheck) {
+    return !IsNullOrEmptyOrContainsSingleEmptyValue(arrayToCheck);
+}
+exports.IsNotNullOrEmptyNorContainsSingleEmptyValue = IsNotNullOrEmptyNorContainsSingleEmptyValue;
+function HasSingleEmptyValue(arrayToCheck) {
+    if (arrayToCheck.length == 1 && arrayToCheck[0] == '') {
+        return true;
+    }
+    return false;
+}
+exports.HasSingleEmptyValue = HasSingleEmptyValue;
+function hasOneItem(arrayToCheck) {
+    return hasItemsOfCount(arrayToCheck, 1);
+}
+exports.hasOneItem = hasOneItem;
+function hasItemsOfCount(arrayToCheck, numberOfItems) {
+    return arrayToCheck.length == numberOfItems;
+}
+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]
+function areArraysEqual(arr1, arr2) {
+    if (IsNullOrEmpty(arr1) && IsNotNullOrEmpty(arr2)) {
+        return false;
+    }
+    if (IsNotNullOrEmpty(arr1) && IsNullOrEmpty(arr2)) {
+        return false;
+    }
+    if (arr1.length !== arr2.length) {
+        return false;
+    }
+    return arr1.every((x) => arr2.indexOf(x) != -1);
+}
+exports.areArraysEqual = areArraysEqual;
+function areArraysNotEqual(arr1, arr2) {
+    return !areArraysEqual(arr1, arr2);
+}
+exports.areArraysNotEqual = areArraysNotEqual;
+function areArraysEqualWithOrder(arr1, arr2) {
+    if (arr1 == null) {
+        return true;
+    }
+    if (arr1.length !== arr2.length) {
+        return false;
+    }
+    return arr1.every((x, index) => arr2.indexOf(x) == index);
+}
+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)) {
+        return false;
+    }
+    // If items are not an object or array, return false
+    if (['[object Array]', '[object Object]'].indexOf(type) < 0) {
+        return false;
+    }
+    // Compare the length of the length of the two items
+    const valueLen = type === '[object Array]' ? value.length : Object.keys(value).length;
+    const otherLen = type === '[object Array]' ? other.length : Object.keys(other).length;
+    if (valueLen !== otherLen) {
+        return false;
+    }
+    // Compare two items
+    const compare = function (item1, item2) {
+        // Get the object type
+        const itemType = Object.prototype.toString.call(item1);
+        // If an object or array, compare recursively
+        if (['[object Array]', '[object Object]'].indexOf(itemType) >= 0) {
+            if (!areArraysEqualWithOrderandProperties(item1, item2)) {
+                return false;
+            }
+        }
+        // Otherwise, do a simple comparison
+        else {
+            // If the two items are not the same type, return false
+            if (itemType !== Object.prototype.toString.call(item2)) {
+                return false;
+            }
+            // Else if it's a function, convert to a string and compare
+            // Otherwise, just compare
+            if (itemType === '[object Function]') {
+                if (item1.toString() !== item2.toString()) {
+                    return false;
+                }
+            }
+            else {
+                if (item1 !== item2) {
+                    return false;
+                }
+            }
+        }
+    };
+    // Compare properties
+    if (type === '[object Array]') {
+        for (let i = 0; i < valueLen; i++) {
+            if (compare(value[i], other[i]) === false) {
+                return false;
+            }
+        }
+    }
+    else {
+        for (let key in value) {
+            if (value.hasOwnProperty(key)) {
+                if (compare(value[key], other[key]) === false) {
+                    return false;
+                }
+            }
+        }
+    }
+    // If nothing failed, return true
+    return true;
+}
+exports.areArraysEqualWithOrderandProperties = areArraysEqualWithOrderandProperties;
+function sortArrayWithProperty(sortOrder, values, sortProperty) {
+    if (sortProperty) {
+        let newValues = [].concat(values);
+        let direction = 1;
+        if (sortOrder == Enums_1.SortOrder.Desc) {
+            direction = -1;
+        }
+        return newValues.sort((a, b) => {
+            let aSortProperty = a[sortProperty];
+            let bSortProperty = b[sortProperty];
+            if (typeof aSortProperty == 'string' && typeof bSortProperty == 'string') {
+                return aSortProperty.localeCompare(bSortProperty) * direction;
+            }
+            else {
+                return aSortProperty < bSortProperty
+                    ? -1 * direction
+                    : aSortProperty > bSortProperty
+                        ? 1 * direction
+                        : 0;
+            }
+        });
+    }
+    else {
+        return sortArray(values, sortOrder);
+    }
+}
+exports.sortArrayWithProperty = sortArrayWithProperty;
+function sortArray(values, sortOrder = Enums_1.SortOrder.Asc) {
+    const newValues = [].concat(values);
+    const direction = sortOrder == Enums_1.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) {
+    const newValues = [].concat(cellValues);
+    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);
+}
+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);
+        const valueBAsNumber = Number(b.rawValue);
+        if (isNaN(valueAAsNumber)) {
+            return 0;
+        }
+        if (isNaN(valueBAsNumber)) {
+            return 0;
+        }
+        return valueAAsNumber < valueBAsNumber
+            ? -1 * direction
+            : valueAAsNumber > valueBAsNumber
+                ? 1 * direction
+                : 0;
+    });
+}
+exports.sortCellValueArrayNumeric = sortCellValueArrayNumeric;
+function sortCellValueArrayDates(cellValues, sortOrder = Enums_1.SortOrder.Asc) {
+    cellValues.sort((a, b) => {
+        return sortOrder == Enums_1.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) {
+    return array.reduce((acc, item) => {
+        let key = item[prop];
+        acc[key] = acc[key] || [];
+        acc[key].push(item);
+        return acc;
+    }, {});
+}
+exports.groupArrayBy = groupArrayBy;
+function createCommaSeparatedString(values) {
+    return values.join(', ');
+}
+exports.createCommaSeparatedString = createCommaSeparatedString;
+exports.ArrayExtensions = {
+    GetLength,
+    CorrectLength,
+    NotCorrectLength,
+    groupArrayBy,
+    AddItem,
+    ContainsItem,
+    NotContainsItem,
+    ContainsAnyItem,
+    RetrieveDistinct,
+    IsNull,
+    IsNotNull,
+    IsEmpty,
+    IsNotEmpty,
+    IsNullOrEmpty,
+    IsNotNullOrEmpty,
+    IsNullOrEmptyOrContainsSingleEmptyValue,
+    IsNotNullOrEmptyNorContainsSingleEmptyValue,
+    HasSingleEmptyValue,
+    hasOneItem,
+    hasItemsOfCount,
+    moveArray,
+    areArraysEqual,
+    areArraysNotEqual,
+    areArraysEqualWithOrder,
+    areArraysEqualWithOrderandProperties,
+    sortArray,
+    sortCellValueArray,
+    sortCellValueArrayNumeric,
+    sortCellValueArrayDates,
+    sortArrayWithProperty,
+    createCommaSeparatedString,
+};
+exports.default = exports.ArrayExtensions;

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

@@ -0,0 +1,11 @@
+export declare function getNames(e: any): string[];
+export declare function getValues<T extends number>(e: any): T[];
+export declare function getObjValues(e: any): (number | string)[];
+export declare function getCssFontSizeFromFontSizeEnum(fontSize: any): string;
+export declare const EnumExtensions: {
+    getNames: typeof getNames;
+    getValues: typeof getValues;
+    getObjValues: typeof getObjValues;
+    getCssFontSizeFromFontSizeEnum: typeof getCssFontSizeFromFontSizeEnum;
+};
+export default EnumExtensions;

package/src/Utilities/Extensions/EnumExtensions.js

@@ -0,0 +1,41 @@
+"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 }));
+// }
+function getNames(e) {
+    return exports.EnumExtensions.getObjValues(e).filter((v) => typeof v === 'string');
+}
+exports.getNames = getNames;
+function getValues(e) {
+    return exports.EnumExtensions.getObjValues(e).filter((v) => typeof v === 'number');
+}
+exports.getValues = getValues;
+function getObjValues(e) {
+    return Object.keys(e).map((k) => e[k]);
+}
+exports.getObjValues = getObjValues;
+function getCssFontSizeFromFontSizeEnum(fontSize) {
+    switch (fontSize) {
+        case Enums_1.FontSize.XLarge:
+            return 'x-large';
+        case Enums_1.FontSize.Large:
+            return 'large';
+        case Enums_1.FontSize.Medium:
+            return 'medium';
+        case Enums_1.FontSize.Small:
+            return 'small';
+        case Enums_1.FontSize.XSmall:
+            return 'x-small';
+    }
+}
+exports.getCssFontSizeFromFontSizeEnum = getCssFontSizeFromFontSizeEnum;
+exports.EnumExtensions = {
+    getNames,
+    getValues,
+    getObjValues,
+    getCssFontSizeFromFontSizeEnum,
+};
+exports.default = exports.EnumExtensions;

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

@@ -0,0 +1,7 @@
+export declare function abbreviateNumber(numberToAbbreviate: number): string;
+export declare function WrapInParentheses(numberToWrap: number): string;
+export declare const NumberExtensions: {
+    abbreviateNumber: typeof abbreviateNumber;
+    WrapInParentheses: typeof WrapInParentheses;
+};
+export default NumberExtensions;

package/src/Utilities/Extensions/NumberExtensions.js

@@ -0,0 +1,29 @@
+"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';
+    }
+    else if (numberToAbbreviate >= 1000000) {
+        str = (numberToAbbreviate / 1000000).toFixed(1) + 'M';
+    }
+    else if (numberToAbbreviate >= 1000) {
+        str = (numberToAbbreviate / 1000).toFixed(1) + 'K';
+    }
+    else {
+        str = numberToAbbreviate.toString();
+    }
+    return str;
+}
+exports.abbreviateNumber = abbreviateNumber;
+function WrapInParentheses(numberToWrap) {
+    return ' (' + numberToWrap + ')';
+}
+exports.WrapInParentheses = WrapInParentheses;
+exports.NumberExtensions = {
+    abbreviateNumber,
+    WrapInParentheses,
+};
+exports.default = exports.NumberExtensions;

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

@@ -0,0 +1,12 @@
+/**
+ * Returns a new object with the property updated.
+ * The property is identified by the path.
+ *
+ * @param obj Object
+ * @param path path to the property
+ * @param value new property value
+ * @returns
+ */
+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

@@ -0,0 +1,28 @@
+"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.
+ *
+ * @param obj Object
+ * @param path path to the property
+ * @param value new property value
+ * @returns
+ */
+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) {
+    return !obj || Object.keys(obj).length === 0;
+}
+exports.isObjectEmpty = isObjectEmpty;
+const deepClone = (obj) => {
+    return JSON.parse(JSON.stringify(obj));
+};
+exports.deepClone = deepClone;

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

@@ -0,0 +1,41 @@
+export declare function IsNull(stringToCheck: string | undefined): boolean;
+export declare function IsNotNull(stringToCheck: string | undefined): boolean;
+export declare function IsEmpty(stringToCheck: string | undefined): boolean;
+export declare function IsNotEmpty(stringToCheck: string | undefined): boolean;
+export declare function IsNullOrEmpty(stringToCheck: string | undefined): boolean;
+export declare function IsNotNullOrEmpty(stringToCheck: string | undefined): boolean;
+export declare function IsNullOrEmptyOrWhiteSpace(stringToCheck: string | undefined): boolean;
+export declare function IsNotNullOrEmptyOrWhiteSpace(stringToCheck: string | undefined): boolean;
+export declare function CamelCaseToHumanText(camelCase: string | undefined): string | null;
+export declare function RemoveTrailingComma(stringToCheck: string): string;
+export declare function ToLowerCase(stringToCheck: string): string;
+export declare function Includes(stringToCheck: string, valueToCheck: string): boolean;
+export declare function NotIncludes(stringToCheck: string, valueToCheck: string): boolean;
+export declare function AbbreviateString(stringToAbbreviate: string, maxLength: number): string;
+export declare function CapitaliseFirstLetter(str: string): string;
+export declare function Humanize(str: string): string;
+export declare function ReplaceEmptySpacesWithUnderscore(str?: string): string;
+export declare function IsNumeric(str: string): boolean;
+export declare function UnescapeHtmlEntities(str: string): string;
+export declare const StringExtensions: {
+    IsNull: typeof IsNull;
+    IsNotNull: typeof IsNotNull;
+    IsEmpty: typeof IsEmpty;
+    IsNotEmpty: typeof IsNotEmpty;
+    IsNullOrEmpty: typeof IsNullOrEmpty;
+    IsNotNullOrEmpty: typeof IsNotNullOrEmpty;
+    IsNullOrEmptyOrWhiteSpace: typeof IsNullOrEmptyOrWhiteSpace;
+    IsNotNullOrEmptyOrWhiteSpace: typeof IsNotNullOrEmptyOrWhiteSpace;
+    CamelCaseToHumanText: typeof CamelCaseToHumanText;
+    RemoveTrailingComma: typeof RemoveTrailingComma;
+    ToLowerCase: typeof ToLowerCase;
+    Includes: typeof Includes;
+    NotIncludes: typeof NotIncludes;
+    AbbreviateString: typeof AbbreviateString;
+    CapitaliseFirstLetter: typeof CapitaliseFirstLetter;
+    Humanize: typeof Humanize;
+    ReplaceEmptySpacesWithUnderscore: typeof ReplaceEmptySpacesWithUnderscore;
+    IsNumeric: typeof IsNumeric;
+    UnescapeHtmlEntities: typeof UnescapeHtmlEntities;
+};
+export default StringExtensions;

package/src/Utilities/Extensions/StringExtensions.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StringExtensions = exports.UnescapeHtmlEntities = exports.IsNumeric = exports.ReplaceEmptySpacesWithUnderscore = exports.Humanize = exports.CapitaliseFirstLetter = exports.AbbreviateString = exports.NotIncludes = exports.Includes = exports.ToLowerCase = exports.RemoveTrailingComma = exports.CamelCaseToHumanText = exports.IsNotNullOrEmptyOrWhiteSpace = exports.IsNullOrEmptyOrWhiteSpace = exports.IsNotNullOrEmpty = exports.IsNullOrEmpty = exports.IsNotEmpty = exports.IsEmpty = exports.IsNotNull = exports.IsNull = void 0;
+const tslib_1 = require("tslib");
+const startCase_1 = tslib_1.__importDefault(require("lodash/startCase"));
+function IsNull(stringToCheck) {
+    return stringToCheck == null || stringToCheck == undefined;
+}
+exports.IsNull = IsNull;
+function IsNotNull(stringToCheck) {
+    return !IsNull(stringToCheck);
+}
+exports.IsNotNull = IsNotNull;
+function IsEmpty(stringToCheck) {
+    return stringToCheck == '';
+}
+exports.IsEmpty = IsEmpty;
+function IsNotEmpty(stringToCheck) {
+    return !IsEmpty(stringToCheck);
+}
+exports.IsNotEmpty = IsNotEmpty;
+function IsNullOrEmpty(stringToCheck) {
+    return IsNull(stringToCheck) || IsEmpty(stringToCheck);
+}
+exports.IsNullOrEmpty = IsNullOrEmpty;
+function IsNotNullOrEmpty(stringToCheck) {
+    return !IsNullOrEmpty(stringToCheck);
+}
+exports.IsNotNullOrEmpty = IsNotNullOrEmpty;
+function IsNullOrEmptyOrWhiteSpace(stringToCheck) {
+    return IsNullOrEmpty(stringToCheck) || IsEmpty(stringToCheck.trim());
+}
+exports.IsNullOrEmptyOrWhiteSpace = IsNullOrEmptyOrWhiteSpace;
+function IsNotNullOrEmptyOrWhiteSpace(stringToCheck) {
+    return !IsNullOrEmptyOrWhiteSpace(stringToCheck);
+}
+exports.IsNotNullOrEmptyOrWhiteSpace = IsNotNullOrEmptyOrWhiteSpace;
+// from https://stackoverflow.com/questions/15369566/putting-space-in-camel-case-string-using-regular-expression
+function CamelCaseToHumanText(camelCase) {
+    if (!camelCase || camelCase == null) {
+        return null;
+    }
+    const rex = /([A-Z])([A-Z])([a-z])|([a-z])([A-Z])/g;
+    const words = camelCase.replace(rex, '$1$4 $2$3$5').replace('.', ' ').split(' ');
+    return words
+        .map((word) => word.substring(0, 1).toUpperCase() + (word.length > 1 ? word.substring(1, word.length) : ''))
+        .join(' ');
+}
+exports.CamelCaseToHumanText = CamelCaseToHumanText;
+function RemoveTrailingComma(stringToCheck) {
+    return stringToCheck.replace(/,\s*$/, '');
+}
+exports.RemoveTrailingComma = RemoveTrailingComma;
+function ToLowerCase(stringToCheck) {
+    return IsNullOrEmpty(stringToCheck) ? stringToCheck : stringToCheck.toLowerCase();
+}
+exports.ToLowerCase = ToLowerCase;
+function Includes(stringToCheck, valueToCheck) {
+    return stringToCheck.includes(valueToCheck);
+}
+exports.Includes = Includes;
+function NotIncludes(stringToCheck, valueToCheck) {
+    return !Includes(stringToCheck, valueToCheck);
+}
+exports.NotIncludes = NotIncludes;
+function AbbreviateString(stringToAbbreviate, maxLength) {
+    return stringToAbbreviate.length < maxLength
+        ? stringToAbbreviate
+        : stringToAbbreviate.substr(0, maxLength) + '...';
+}
+exports.AbbreviateString = AbbreviateString;
+function CapitaliseFirstLetter(str) {
+    return `${str.charAt(0).toUpperCase()}${str.substring(1)}`;
+}
+exports.CapitaliseFirstLetter = CapitaliseFirstLetter;
+function Humanize(str) {
+    return (0, startCase_1.default)(str);
+}
+exports.Humanize = Humanize;
+function ReplaceEmptySpacesWithUnderscore(str = '') {
+    return str.replace(/ /g, '_');
+}
+exports.ReplaceEmptySpacesWithUnderscore = ReplaceEmptySpacesWithUnderscore;
+function IsNumeric(str) {
+    if (typeof str !== 'string') {
+        return false;
+    }
+    return !isNaN(parseFloat(str));
+}
+exports.IsNumeric = IsNumeric;
+function UnescapeHtmlEntities(str) {
+    if (!str || typeof str !== 'string') {
+        return str;
+    }
+    let preparedStr = str;
+    const map = [
+        { target: /&apos;|&#39;/gi, replacement: "'" },
+        { target: /&quot;|&#34;/gi, replacement: '"' },
+        { target: /&amp;|&#38;/gi, replacement: '&' },
+        { target: /&lt;|&#60;/gi, replacement: '<' },
+        { target: /&gt;|&#62;/gi, replacement: '>' },
+        { target: /&nbsp;|&#160;/gi, replacement: ' ' },
+    ];
+    for (const transform of map) {
+        preparedStr = preparedStr.replace(transform.target, transform.replacement);
+    }
+    return preparedStr;
+}
+exports.UnescapeHtmlEntities = UnescapeHtmlEntities;
+exports.StringExtensions = {
+    IsNull,
+    IsNotNull,
+    IsEmpty,
+    IsNotEmpty,
+    IsNullOrEmpty,
+    IsNotNullOrEmpty,
+    IsNullOrEmptyOrWhiteSpace,
+    IsNotNullOrEmptyOrWhiteSpace,
+    CamelCaseToHumanText,
+    RemoveTrailingComma,
+    ToLowerCase,
+    Includes,
+    NotIncludes,
+    AbbreviateString,
+    CapitaliseFirstLetter,
+    Humanize,
+    ReplaceEmptySpacesWithUnderscore,
+    IsNumeric,
+    UnescapeHtmlEntities,
+};
+exports.default = exports.StringExtensions;