@adaptabletools/adaptable-cjs 23.0.0-canary.1 → 23.0.0-canary.10

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

@@ -13,3 +13,47 @@ export declare const deepClone: (obj: any) => any;
 export declare const diff: <T extends {
     [key: string]: unknown;
 }>(obj1: T, obj2: T) => (keyof T)[];
+/**
+ * Checks if `value` is the language type of Object.
+ * (e.g. arrays, functions, objects, regexes, new Number(0), and new String(''))
+ * Drop-in replacement for lodash/isObject.
+ */
+export declare function isObject(value: any): value is object;
+/**
+ * Checks if `value` is a plain object, that is, an object created by the
+ * Object constructor or one with a [[Prototype]] of null.
+ * Drop-in replacement for lodash/isPlainObject.
+ */
+export declare function isPlainObject(value: any): value is Record<string, any>;
+/**
+ * Performs a deep comparison between two values to determine if they are equivalent.
+ * Drop-in replacement for lodash/isEqual.
+ */
+export declare function isEqual(value: any, other: any): boolean;
+type CloneCustomizer = (value: any) => any;
+/**
+ * Like `cloneDeep` except that it accepts a customizer which is invoked to
+ * produce the cloned value. If the customizer returns `undefined`, cloning is
+ * handled by the method instead.
+ * Drop-in replacement for lodash/cloneDeepWith.
+ */
+export declare function cloneDeepWith<T>(value: T, customizer: CloneCustomizer): T;
+/**
+ * Recursively merges own enumerable string-keyed properties of source objects
+ * into `target`. Source properties that resolve to `undefined` are skipped if a
+ * destination value exists. Array and plain object properties are merged
+ * recursively; other values are overridden by assignment.
+ * Drop-in replacement for lodash/merge.
+ */
+export declare function merge<TObject, TSource1>(object: TObject, source1: TSource1): TObject & TSource1;
+export declare function merge<TObject, TSource1, TSource2>(object: TObject, source1: TSource1, source2: TSource2): TObject & TSource1 & TSource2;
+export declare function merge<TObject, TSource1, TSource2, TSource3>(object: TObject, source1: TSource1, source2: TSource2, source3: TSource3): TObject & TSource1 & TSource2 & TSource3;
+export declare function merge(target: any, ...sources: any[]): any;
+/**
+ * Like `merge` except that it accepts a customizer which is invoked to produce
+ * the merged values of the destination and source properties. If the customizer
+ * returns `undefined`, merging is handled by the method instead.
+ * Drop-in replacement for lodash/mergeWith.
+ */
+export declare function mergeWith<T extends object>(target: T, ...args: any[]): T;
+export {};

package/src/Utilities/Extensions/ObjectExtensions.js

@@ -3,6 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.diff = exports.deepClone = void 0;
 exports.setInPath = setInPath;
 exports.isObjectEmpty = isObjectEmpty;
+exports.isObject = isObject;
+exports.isPlainObject = isPlainObject;
+exports.isEqual = isEqual;
+exports.cloneDeepWith = cloneDeepWith;
+exports.merge = merge;
+exports.mergeWith = mergeWith;
 /**
  * Returns a new object with the property updated.
  * The property is identified by the path.
@@ -41,3 +47,274 @@ const diff = (obj1, obj2) => {
     return changed;
 };
 exports.diff = diff;
+/**
+ * Checks if `value` is the language type of Object.
+ * (e.g. arrays, functions, objects, regexes, new Number(0), and new String(''))
+ * Drop-in replacement for lodash/isObject.
+ */
+function isObject(value) {
+    const type = typeof value;
+    return value != null && (type === 'object' || type === 'function');
+}
+/**
+ * Checks if `value` is a plain object, that is, an object created by the
+ * Object constructor or one with a [[Prototype]] of null.
+ * Drop-in replacement for lodash/isPlainObject.
+ */
+function isPlainObject(value) {
+    if (value === null || value === undefined || typeof value !== 'object') {
+        return false;
+    }
+    const proto = Object.getPrototypeOf(value);
+    if (proto === null) {
+        return true;
+    }
+    return proto === Object.prototype;
+}
+/**
+ * Performs a deep comparison between two values to determine if they are equivalent.
+ * Drop-in replacement for lodash/isEqual.
+ */
+function isEqual(value, other) {
+    return _baseIsEqual(value, other, new Map());
+}
+function _baseIsEqual(a, b, seen) {
+    if (a === b) {
+        return true;
+    }
+    if (a !== a && b !== b) {
+        return true;
+    }
+    if (a == null || b == null) {
+        return false;
+    }
+    const typeA = typeof a;
+    const typeB = typeof b;
+    if (typeA !== typeB) {
+        return false;
+    }
+    if (typeA !== 'object') {
+        return false;
+    }
+    if (a instanceof Date && b instanceof Date) {
+        return a.getTime() === b.getTime();
+    }
+    if (a instanceof RegExp && b instanceof RegExp) {
+        return a.source === b.source && a.flags === b.flags;
+    }
+    if (a instanceof Date !== b instanceof Date) {
+        return false;
+    }
+    if (a instanceof RegExp !== b instanceof RegExp) {
+        return false;
+    }
+    if (seen.has(a)) {
+        return seen.get(a) === b;
+    }
+    seen.set(a, b);
+    if (Array.isArray(a)) {
+        if (!Array.isArray(b) || a.length !== b.length) {
+            return false;
+        }
+        for (let i = 0; i < a.length; i++) {
+            if (!_baseIsEqual(a[i], b[i], seen)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    if (Array.isArray(b)) {
+        return false;
+    }
+    if (a instanceof Map && b instanceof Map) {
+        if (a.size !== b.size) {
+            return false;
+        }
+        for (const [key, val] of a) {
+            if (!b.has(key) || !_baseIsEqual(val, b.get(key), seen)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    // Unordered deep comparison for Sets, matching lodash behaviour
+    if (a instanceof Set && b instanceof Set) {
+        if (a.size !== b.size) {
+            return false;
+        }
+        for (const valA of a) {
+            let found = false;
+            for (const valB of b) {
+                if (_baseIsEqual(valA, valB, new Map(seen))) {
+                    found = true;
+                    break;
+                }
+            }
+            if (!found) {
+                return false;
+            }
+        }
+        return true;
+    }
+    if (ArrayBuffer.isView(a) && ArrayBuffer.isView(b)) {
+        const viewA = a;
+        const viewB = b;
+        if (viewA.length !== viewB.length) {
+            return false;
+        }
+        for (let i = 0; i < viewA.length; i++) {
+            if (viewA[i] !== viewB[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    const keysA = Object.keys(a);
+    const keysB = Object.keys(b);
+    if (keysA.length !== keysB.length) {
+        return false;
+    }
+    for (const key of keysA) {
+        if (!Object.prototype.hasOwnProperty.call(b, key)) {
+            return false;
+        }
+        if (!_baseIsEqual(a[key], b[key], seen)) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Like `cloneDeep` except that it accepts a customizer which is invoked to
+ * produce the cloned value. If the customizer returns `undefined`, cloning is
+ * handled by the method instead.
+ * Drop-in replacement for lodash/cloneDeepWith.
+ */
+function cloneDeepWith(value, customizer) {
+    return _baseCloneDeep(value, customizer, new Map());
+}
+function _baseCloneDeep(value, customizer, seen) {
+    const customResult = customizer(value);
+    if (customResult !== undefined) {
+        return customResult;
+    }
+    if (value === null || typeof value !== 'object') {
+        return value;
+    }
+    if (seen.has(value)) {
+        return seen.get(value);
+    }
+    if (value instanceof Date) {
+        return new Date(value.getTime());
+    }
+    if (value instanceof RegExp) {
+        return new RegExp(value.source, value.flags);
+    }
+    if (value instanceof Map) {
+        const cloned = new Map();
+        seen.set(value, cloned);
+        value.forEach((v, k) => {
+            cloned.set(_baseCloneDeep(k, customizer, seen), _baseCloneDeep(v, customizer, seen));
+        });
+        return cloned;
+    }
+    if (value instanceof Set) {
+        const cloned = new Set();
+        seen.set(value, cloned);
+        value.forEach((v) => {
+            cloned.add(_baseCloneDeep(v, customizer, seen));
+        });
+        return cloned;
+    }
+    if (Array.isArray(value)) {
+        const cloned = [];
+        seen.set(value, cloned);
+        for (let i = 0; i < value.length; i++) {
+            cloned[i] = _baseCloneDeep(value[i], customizer, seen);
+        }
+        return cloned;
+    }
+    const cloned = Object.create(Object.getPrototypeOf(value));
+    seen.set(value, cloned);
+    const keys = Object.keys(value);
+    for (const key of keys) {
+        cloned[key] = _baseCloneDeep(value[key], customizer, seen);
+    }
+    return cloned;
+}
+function _baseMerge(target, source) {
+    if (source == null) {
+        return target;
+    }
+    const keys = Object.keys(source);
+    for (const key of keys) {
+        const srcValue = source[key];
+        const tgtValue = target[key];
+        if (Array.isArray(srcValue)) {
+            if (!Array.isArray(tgtValue)) {
+                target[key] = [];
+            }
+            _baseMerge(target[key], srcValue);
+        }
+        else if (isPlainObject(srcValue)) {
+            if (!isPlainObject(tgtValue)) {
+                target[key] = {};
+            }
+            _baseMerge(target[key], srcValue);
+        }
+        else if (srcValue !== undefined) {
+            target[key] = srcValue;
+        }
+    }
+    return target;
+}
+function merge(target, ...sources) {
+    for (const source of sources) {
+        _baseMerge(target, source);
+    }
+    return target;
+}
+function _baseMergeWith(target, source, customizer) {
+    if (source == null) {
+        return target;
+    }
+    const keys = Object.keys(source);
+    for (const key of keys) {
+        const srcValue = source[key];
+        const tgtValue = target[key];
+        const customResult = customizer(tgtValue, srcValue, key, target, source);
+        if (customResult !== undefined) {
+            target[key] = customResult;
+        }
+        else if (Array.isArray(srcValue)) {
+            if (!Array.isArray(tgtValue)) {
+                target[key] = [];
+            }
+            _baseMergeWith(target[key], srcValue, customizer);
+        }
+        else if (isPlainObject(srcValue)) {
+            if (!isPlainObject(tgtValue)) {
+                target[key] = {};
+            }
+            _baseMergeWith(target[key], srcValue, customizer);
+        }
+        else if (srcValue !== undefined) {
+            target[key] = srcValue;
+        }
+    }
+    return target;
+}
+/**
+ * Like `merge` except that it accepts a customizer which is invoked to produce
+ * the merged values of the destination and source properties. If the customizer
+ * returns `undefined`, merging is handled by the method instead.
+ * Drop-in replacement for lodash/mergeWith.
+ */
+function mergeWith(target, ...args) {
+    const customizer = args[args.length - 1];
+    const sources = args.slice(0, -1);
+    for (const source of sources) {
+        _baseMergeWith(target, source, customizer);
+    }
+    return target;
+}

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

@@ -18,6 +18,28 @@ export declare function ReplaceEmptySpacesWithUnderscore(str?: string): string;
 export declare function IsNumeric(str: string): boolean;
 export declare function UnescapeHtmlEntities(str: string): string;
 export declare function ReplaceAllOccurencesExceptLastOne(str: string, searchTerm: string, replacement: string): string;
+/**
+ * Splits a string into words: handles camelCase, PascalCase, UPPER_CASE,
+ * UPPER_SNAKE_CASE, snake_case, kebab-case, spaces, and dot.notation.
+ * Shared helper used by `kebabCase`, `startCase`, and `sentenceCase`.
+ */
+export declare function words(str: string): string[];
+/**
+ * Converts string to kebab-case.
+ * Drop-in replacement for lodash/kebabCase.
+ */
+export declare function kebabCase(string: string): string;
+/**
+ * Converts string to Start Case.
+ * Drop-in replacement for lodash/startCase.
+ */
+export declare function startCase(string: string): string;
+/**
+ * Converts string to Sentence case.
+ * Splits on camelCase, PascalCase, dots, underscores, hyphens, and non-alphanumeric characters.
+ * Drop-in replacement for the sentence-case package.
+ */
+export declare function sentenceCase(input: string): string;
 export declare const StringExtensions: {
     IsNull: typeof IsNull;
     IsNotNull: typeof IsNotNull;
@@ -39,5 +61,9 @@ export declare const StringExtensions: {
     IsNumeric: typeof IsNumeric;
     UnescapeHtmlEntities: typeof UnescapeHtmlEntities;
     ReplaceAllOccurencesExceptLastOne: typeof ReplaceAllOccurencesExceptLastOne;
+    words: typeof words;
+    kebabCase: typeof kebabCase;
+    startCase: typeof startCase;
+    sentenceCase: typeof sentenceCase;
 };
 export default StringExtensions;

package/src/Utilities/Extensions/StringExtensions.js

@@ -21,8 +21,10 @@ exports.ReplaceEmptySpacesWithUnderscore = ReplaceEmptySpacesWithUnderscore;
 exports.IsNumeric = IsNumeric;
 exports.UnescapeHtmlEntities = UnescapeHtmlEntities;
 exports.ReplaceAllOccurencesExceptLastOne = ReplaceAllOccurencesExceptLastOne;
-const tslib_1 = require("tslib");
-const startCase_1 = tslib_1.__importDefault(require("../utils/startCase"));
+exports.words = words;
+exports.kebabCase = kebabCase;
+exports.startCase = startCase;
+exports.sentenceCase = sentenceCase;
 function IsNull(stringToCheck) {
     return stringToCheck == null || stringToCheck == undefined;
 }
@@ -87,7 +89,7 @@ function CapitaliseFirstLetter(str) {
     return `${str.charAt(0).toUpperCase()}${str.substring(1)}`;
 }
 function Humanize(str) {
-    return (0, startCase_1.default)(str);
+    return startCase(str);
 }
 function ReplaceEmptySpacesWithUnderscore(str = '') {
     return str.replace(/ /g, '_');
@@ -131,6 +133,46 @@ function ReplaceAllOccurencesExceptLastOne(str, searchTerm, replacement) {
     // Recombine the modified first part with the untouched second part
     return replacedPart + partAfterLast;
 }
+/**
+ * Splits a string into words: handles camelCase, PascalCase, UPPER_CASE,
+ * UPPER_SNAKE_CASE, snake_case, kebab-case, spaces, and dot.notation.
+ * Shared helper used by `kebabCase`, `startCase`, and `sentenceCase`.
+ */
+function words(str) {
+    const matches = str.match(/[A-Z]?[a-z]+|[A-Z]+(?=[A-Z][a-z]|\d|$|[^a-zA-Z0-9])|[A-Z]|[0-9]+/g);
+    return matches || [];
+}
+function _capitalizeWord(word) {
+    return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
+}
+/**
+ * Converts string to kebab-case.
+ * Drop-in replacement for lodash/kebabCase.
+ */
+function kebabCase(string) {
+    return words(string).map((w) => w.toLowerCase()).join('-');
+}
+/**
+ * Converts string to Start Case.
+ * Drop-in replacement for lodash/startCase.
+ */
+function startCase(string) {
+    return words(string).map(_capitalizeWord).join(' ');
+}
+/**
+ * Converts string to Sentence case.
+ * Splits on camelCase, PascalCase, dots, underscores, hyphens, and non-alphanumeric characters.
+ * Drop-in replacement for the sentence-case package.
+ */
+function sentenceCase(input) {
+    const parts = words(input);
+    if (parts.length === 0) {
+        return '';
+    }
+    return parts
+        .map((w, i) => (i === 0 ? w.charAt(0).toUpperCase() + w.slice(1).toLowerCase() : w.toLowerCase()))
+        .join(' ');
+}
 exports.StringExtensions = {
     IsNull,
     IsNotNull,
@@ -152,5 +194,9 @@ exports.StringExtensions = {
     IsNumeric,
     UnescapeHtmlEntities,
     ReplaceAllOccurencesExceptLastOne,
+    words,
+    kebabCase,
+    startCase,
+    sentenceCase,
 };
 exports.default = exports.StringExtensions;

package/src/Utilities/Helpers/AdaptableHelper.js

@@ -9,8 +9,8 @@ exports.removeAdaptableObjectPrimitivesInline = removeAdaptableObjectPrimitivesI
 exports.removeAdaptableObjectPrimitives = removeAdaptableObjectPrimitives;
 exports.isAdaptableObject = isAdaptableObject;
 const tslib_1 = require("tslib");
-const cloneDeepWith_1 = tslib_1.__importDefault(require("../utils/cloneDeepWith"));
-const isPlainObject_1 = tslib_1.__importDefault(require("../utils/isPlainObject"));
+const ObjectExtensions_1 = require("../Extensions/ObjectExtensions");
+const ObjectExtensions_2 = require("../Extensions/ObjectExtensions");
 const Uuid_1 = require("../../AdaptableState/Uuid");
 const GeneralConstants_1 = require("../Constants/GeneralConstants");
 const package_json_1 = tslib_1.__importDefault(require("../../../package.json"));
@@ -27,19 +27,19 @@ function addUuidsToInitialState(initialState) {
     const objectsToEnrich = new Set();
     for (const moduleKey in initialState) {
         const moduleState = initialState[moduleKey];
-        if ((0, isPlainObject_1.default)(moduleState)) {
+        if ((0, ObjectExtensions_2.isPlainObject)(moduleState)) {
             objectsToEnrich.add(moduleState);
             for (const key in moduleState) {
                 const value = moduleState[key];
                 if (Array.isArray(value)) {
                     for (const item of value) {
-                        if ((0, isPlainObject_1.default)(item)) {
+                        if ((0, ObjectExtensions_2.isPlainObject)(item)) {
                             objectsToEnrich.add(item);
                             // ColumnFilters are nested inside Layouts but need Uuid
                             // for identification (suspend/unsuspend, edit vs add, etc.)
                             if (Array.isArray(item.ColumnFilters)) {
                                 for (const filter of item.ColumnFilters) {
-                                    if ((0, isPlainObject_1.default)(filter)) {
+                                    if ((0, ObjectExtensions_2.isPlainObject)(filter)) {
                                         objectsToEnrich.add(filter);
                                     }
                                 }
@@ -51,7 +51,7 @@ function addUuidsToInitialState(initialState) {
         }
     }
     const customizer = (value) => {
-        if ((0, isPlainObject_1.default)(value) && objectsToEnrich.has(value)) {
+        if ((0, ObjectExtensions_2.isPlainObject)(value) && objectsToEnrich.has(value)) {
             if (value.Uuid == null || value.Uuid == undefined) {
                 value.Uuid = (0, Uuid_1.createUuid)();
             }
@@ -60,7 +60,7 @@ function addUuidsToInitialState(initialState) {
             }
         }
     };
-    return (0, cloneDeepWith_1.default)(initialState, customizer);
+    return (0, ObjectExtensions_1.cloneDeepWith)(initialState, customizer);
 }
 function getAccessLevelForObject(adaptableObject, moduleAccessLevel) {
     // we always return the Module Access Level unless the following condition is met:

package/src/Utilities/Helpers/{alertFormHelper.js → AlertHelper.js}

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveAlertFormForDefinition = resolveAlertFormForDefinition;
-const ScheduledAlertHelper_1 = require("./ScheduledAlertHelper");
+const ScheduledAlertHelper_1 = require("./Scheduling/ScheduledAlertHelper");
 function resolveAlertFormForDefinition(alert, defaultForm) {
     if ((0, ScheduledAlertHelper_1.isScheduledAlertDefinition)(alert)) {
         if (!alert.AlertProperties?.DisplayNotification) {

package/src/Utilities/Helpers/DateHelper.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseDateValue = exports.parseToISO = exports.dateToISO = exports.isValueValidDate = exports.isValidDate = void 0;
 const date_fns_1 = require("date-fns");
-const FormatHelper_1 = require("./FormatHelper");
+const DisplayFormatHelper_1 = require("./DisplayFormatHelper");
 const AdaptableLogger_1 = require("../../agGrid/AdaptableLogger");
 const isValidDate = (date) => {
     return date instanceof Date && !isNaN(date.getTime());
@@ -22,7 +22,7 @@ const isValueValidDate = (data) => {
 };
 exports.isValueValidDate = isValueValidDate;
 const dateToISO = (date) => {
-    return (0, FormatHelper_1.DateFormatter)(date, { Pattern: 'yyyy-MM-dd' });
+    return (0, DisplayFormatHelper_1.DateFormatter)(date, { Pattern: 'yyyy-MM-dd' });
 };
 exports.dateToISO = dateToISO;
 const parseToISO = (date, dateFormat) => {

package/src/Utilities/Helpers/{FormatHelper.js → DisplayFormatHelper.js}

@@ -6,10 +6,24 @@ exports.StringFormatter = StringFormatter;
 const tslib_1 = require("tslib");
 // TODO inspect why the following is erroring on angular build
 const date_fns_1 = require("date-fns");
-const sentenceCase_1 = tslib_1.__importDefault(require("../utils/sentenceCase"));
+const StringExtensions_1 = require("../Extensions/StringExtensions");
 const GeneralConstants_1 = require("../Constants/GeneralConstants");
 const Helper_1 = tslib_1.__importDefault(require("./Helper"));
-const StringExtensions_1 = tslib_1.__importDefault(require("../Extensions/StringExtensions"));
+const StringExtensions_2 = tslib_1.__importDefault(require("../Extensions/StringExtensions"));
+const getInputFractionDigitCount = (input) => {
+    const fraction = String(input).split('.')[1];
+    return fraction ? fraction.replace(/0+$/, '').length : 0;
+};
+const getFractionDigitsAfterMultiplier = (input, multiplier, explicitFractionDigits) => {
+    if (explicitFractionDigits != null) {
+        return explicitFractionDigits;
+    }
+    if (multiplier === 1) {
+        return getInputFractionDigitCount(input);
+    }
+    const multiplierPower = Math.round(Math.log10(Math.abs(multiplier)));
+    return Math.max(0, getInputFractionDigitCount(input) - multiplierPower);
+};
 function NumberFormatter(input, options = {}, rowNode, column, api) {
     let preparedInput;
     if (options.Content) {
@@ -35,9 +49,11 @@ function NumberFormatter(input, options = {}, rowNode, column, api) {
         return preparedInput.toString();
     }
     let multiplier = options.Multiplier ? options.Multiplier : 1;
+    let multiplierFractionDigits;
     if (options.Multiplier !== undefined) {
         n *= multiplier;
-        n = parseFloat(n.toFixed(12));
+        multiplierFractionDigits = getFractionDigitsAfterMultiplier(preparedInput, options.Multiplier, options.FractionDigits);
+        n = parseFloat(n.toFixed(multiplierFractionDigits));
     }
     // Set Integer and Fraction Digits to a max of 20
     if (options.IntegerDigits > 20) {
@@ -68,6 +84,9 @@ function NumberFormatter(input, options = {}, rowNode, column, api) {
     if (options.Empty) {
         return ' ';
     }
+    if (n === 0 && options.ZeroDisplay !== undefined && options.ZeroDisplay !== '0') {
+        return options.ZeroDisplay;
+    }
     let s;
     let digitsToUse;
     const fractionsSepatator = options.FractionSeparator ?? '.';
@@ -77,6 +96,9 @@ function NumberFormatter(input, options = {}, rowNode, column, api) {
     else if (options.FractionDigits != null) {
         digitsToUse = options.FractionDigits;
     }
+    else if (multiplierFractionDigits != null) {
+        digitsToUse = multiplierFractionDigits;
+    }
     else {
         let decimalCount = Math.floor(n) === n ? 0 : n.toString().split(fractionsSepatator)[1]?.length || 0;
         digitsToUse = decimalCount;
@@ -106,7 +128,7 @@ function NumberFormatter(input, options = {}, rowNode, column, api) {
             }
             else {
                 // otherwise don't replace the last instance
-                s = StringExtensions_1.default.ReplaceAllOccurencesExceptLastOne(s, ',', options.IntegerSeparator);
+                s = StringExtensions_2.default.ReplaceAllOccurencesExceptLastOne(s, ',', options.IntegerSeparator);
             }
         }
     }
@@ -165,7 +187,7 @@ function StringFormatter(input, options = {}, rowNode, column, api) {
     else {
         preparedInput = normalisedTextInput;
     }
-    if (StringExtensions_1.default.IsNullOrEmptyOrWhiteSpace(preparedInput)) {
+    if (StringExtensions_2.default.IsNullOrEmptyOrWhiteSpace(preparedInput)) {
         return undefined;
     }
     if (options.Empty) {
@@ -186,7 +208,7 @@ function StringFormatter(input, options = {}, rowNode, column, api) {
             s = s.toUpperCase();
         }
         else if (options.Case == 'Sentence') {
-            s = (0, sentenceCase_1.default)(s);
+            s = (0, StringExtensions_1.sentenceCase)(s);
         }
     }
     if (options.Trim !== undefined && options.Trim == true) {

package/src/Utilities/Helpers/Helper.d.ts

@@ -10,9 +10,6 @@ export declare function copyToClipboard(text: string): Promise<boolean>;
 export declare function returnItemCount(items: any[], itemName: string): string;
 export declare function isInputNullOrEmpty(itemToCheck: any): boolean;
 export declare function isInputNotNullOrEmpty(itemToCheck: any): boolean;
-export declare function roundNumber(numberToRound: any, decimalPlaces: number): number;
-export declare function roundNumberTo4dp(numberToRound: any): number;
-export declare function clamp(value: any, boundOne: number, boundTwo: number): number;
 export declare function extractColsFromText(text: string): string[];
 export declare function replaceAll(text: string, toReplace: string, replaceWith: string): string;
 export declare function extractContextKeysFromText(text: string): string[];
@@ -28,9 +25,6 @@ export declare const Helper: {
     returnItemCount: typeof returnItemCount;
     isInputNullOrEmpty: typeof isInputNullOrEmpty;
     isInputNotNullOrEmpty: typeof isInputNotNullOrEmpty;
-    roundNumber: typeof roundNumber;
-    roundNumberTo4dp: typeof roundNumberTo4dp;
-    clamp: typeof clamp;
     extractColsFromText: typeof extractColsFromText;
     replaceAll: typeof replaceAll;
     extractContextKeysFromText: typeof extractContextKeysFromText;