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

package/src/Utilities/Extensions/NumberExtensions.js

@@ -77,11 +77,85 @@ export function avoidJavascriptPrecisionIssues(value) {
     }
     return newValue;
 }
+/**
+ * Clamps `number` within the inclusive `lower` and `upper` bounds.
+ * Drop-in replacement for lodash/clamp.
+ */
+export function clamp(value, lower, upper) {
+    return Math.min(Math.max(value, lower), upper);
+}
+export function roundNumber(numberToRound, decimalPlaces) {
+    switch (decimalPlaces) {
+        case 1:
+            return Math.round(numberToRound * 10) / 10;
+        case 2:
+            return Math.round(numberToRound * 100) / 100;
+        case 3:
+            return Math.round(numberToRound * 1000) / 1000;
+        case 4:
+            return Math.round(numberToRound * 10000) / 10000;
+        case 5:
+            return Math.round(numberToRound * 100000) / 100000;
+        case 6:
+            return Math.round(numberToRound * 1000000) / 1000000;
+    }
+}
+const _reTrimStart = /^\s+/;
+const _reTrimEnd = /\s+$/;
+const _reIsBinary = /^0b[01]+$/i;
+const _reIsOctal = /^0o[0-7]+$/i;
+const _reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
+/**
+ * Converts value to a number.
+ * Drop-in replacement for lodash/toNumber.
+ */
+export function toNumber(value) {
+    if (typeof value === 'number') {
+        return value;
+    }
+    if (typeof value === 'symbol') {
+        return NaN;
+    }
+    if (typeof value === 'boolean') {
+        return value ? 1 : 0;
+    }
+    if (value == null) {
+        return value === undefined ? NaN : 0;
+    }
+    if (typeof value === 'string') {
+        const trimmed = value.replace(_reTrimStart, '').replace(_reTrimEnd, '');
+        if (_reIsBinary.test(trimmed)) {
+            return globalThis.parseInt(trimmed.slice(2), 2);
+        }
+        if (_reIsOctal.test(trimmed)) {
+            return globalThis.parseInt(trimmed.slice(2), 8);
+        }
+        if (_reIsBadHex.test(trimmed)) {
+            return NaN;
+        }
+        return +trimmed;
+    }
+    const other = typeof value.valueOf === 'function' ? value.valueOf() : value;
+    return +other;
+}
+/**
+ * Converts string to an integer of the specified radix.
+ * If radix is undefined or 0, a radix of 10 is used (unlike native parseInt which auto-detects).
+ * Drop-in replacement for lodash/parseInt.
+ */
+export function parseIntFn(string, radix) {
+    const str = typeof string === 'string' ? string.trim() : String(string);
+    return globalThis.parseInt(str, radix || 10);
+}
 export const NumberExtensions = {
     abbreviateNumber,
     wrapInParentheses,
     timesBy100,
     divideBy100,
     avoidJavascriptPrecisionIssues,
+    clamp,
+    roundNumber,
+    toNumber,
+    parseIntFn,
 };
 export default NumberExtensions;

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

@@ -34,3 +34,274 @@ export const diff = (obj1, obj2) => {
     }
     return changed;
 };
+/**
+ * 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 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.
+ */
+export 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.
+ */
+export 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.
+ */
+export 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;
+}
+export 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.
+ */
+export 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

@@ -1,4 +1,3 @@
-import startCase from '../utils/startCase';
 export function IsNull(stringToCheck) {
     return stringToCheck == null || stringToCheck == undefined;
 }
@@ -107,6 +106,46 @@ export 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`.
+ */
+export 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.
+ */
+export function kebabCase(string) {
+    return words(string).map((w) => w.toLowerCase()).join('-');
+}
+/**
+ * Converts string to Start Case.
+ * Drop-in replacement for lodash/startCase.
+ */
+export 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.
+ */
+export 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(' ');
+}
 export const StringExtensions = {
     IsNull,
     IsNotNull,
@@ -128,5 +167,9 @@ export const StringExtensions = {
     IsNumeric,
     UnescapeHtmlEntities,
     ReplaceAllOccurencesExceptLastOne,
+    words,
+    kebabCase,
+    startCase,
+    sentenceCase,
 };
 export default StringExtensions;

package/src/Utilities/Helpers/AdaptableHelper.js

@@ -1,5 +1,5 @@
-import cloneDeepWith from '../utils/cloneDeepWith';
-import isPlainObject from '../utils/isPlainObject';
+import { cloneDeepWith } from '../Extensions/ObjectExtensions';
+import { isPlainObject } from '../Extensions/ObjectExtensions';
 import { createUuid } from '../../AdaptableState/Uuid';
 import { ACCESS_LEVEL_FULL, ACCESS_LEVEL_READ_ONLY, } from '../Constants/GeneralConstants';
 import packageJson from '../../../package.json';

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

@@ -1,4 +1,4 @@
-import { getScheduledAlertNotificationForm, isScheduledAlertDefinition, } from './ScheduledAlertHelper';
+import { getScheduledAlertNotificationForm, isScheduledAlertDefinition, } from './Scheduling/ScheduledAlertHelper';
 export function resolveAlertFormForDefinition(alert, defaultForm) {
     if (isScheduledAlertDefinition(alert)) {
         if (!alert.AlertProperties?.DisplayNotification) {

package/src/Utilities/Helpers/DateHelper.js

@@ -1,5 +1,5 @@
 import { parseISO, parse } from 'date-fns';
-import { DateFormatter } from './FormatHelper';
+import { DateFormatter } from './DisplayFormatHelper';
 import { AdaptableLogger } from '../../agGrid/AdaptableLogger';
 export const isValidDate = (date) => {
     return date instanceof Date && !isNaN(date.getTime());

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

@@ -1,9 +1,23 @@
 // TODO inspect why the following is erroring on angular build
 import { format as dateFnsFormat } from 'date-fns';
-import sentenceCase from '../utils/sentenceCase';
+import { sentenceCase } from '../Extensions/StringExtensions';
 import { DEFAULT_DATE_FORMAT_PATTERN } from '../Constants/GeneralConstants';
 import Helper from './Helper';
 import StringExtensions from '../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);
+};
 export function NumberFormatter(input, options = {}, rowNode, column, api) {
     let preparedInput;
     if (options.Content) {
@@ -29,9 +43,11 @@ export 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) {
@@ -62,6 +78,9 @@ export 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 ?? '.';
@@ -71,6 +90,9 @@ export 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;

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;

package/src/Utilities/Helpers/Helper.js

@@ -140,38 +140,6 @@ export function isInputNullOrEmpty(itemToCheck) {
 export function isInputNotNullOrEmpty(itemToCheck) {
     return !isInputNullOrEmpty(itemToCheck);
 }
-export function roundNumber(numberToRound, decimalPlaces) {
-    switch (decimalPlaces) {
-        case 1:
-            return Math.round(numberToRound * 10) / 10;
-        case 2:
-            return Math.round(numberToRound * 100) / 100;
-        case 3:
-            return Math.round(numberToRound * 1000) / 1000;
-        case 4:
-            return Math.round(numberToRound * 10000) / 10000;
-        case 5:
-            return Math.round(numberToRound * 100000) / 100000;
-        case 6:
-            return Math.round(numberToRound * 1000000) / 1000000;
-    }
-}
-export function roundNumberTo4dp(numberToRound) {
-    return roundNumber(numberToRound, 4);
-}
-// putting this here to remove lodash clamp which seems to cause an issue
-export function clamp(value, boundOne, boundTwo) {
-    if (!boundTwo) {
-        return Math.max(value, boundOne) === boundOne ? value : boundOne;
-    }
-    else if (Math.min(value, boundOne) === value) {
-        return boundOne;
-    }
-    else if (Math.max(value, boundTwo) === value) {
-        return boundTwo;
-    }
-    return value;
-}
 export function extractColsFromText(text) {
     // rowData.columnName => columnName
     const regex = /\[rowData\.(.*?)\]/g;
@@ -212,9 +180,6 @@ export const Helper = {
     returnItemCount,
     isInputNullOrEmpty,
     isInputNotNullOrEmpty,
-    roundNumber,
-    roundNumberTo4dp,
-    clamp,
     extractColsFromText,
     replaceAll,
     extractContextKeysFromText,

package/src/Utilities/Helpers/{QuickSearchStyleHelper.js → QuickSearchHelper.js}

@@ -1,6 +1,6 @@
 import { QUICK_SEARCH_DEFAULT_CURRENT_TEXT_MATCH_STYLE, QUICK_SEARCH_DEFAULT_TEXT_MATCH_STYLE, } from '../../Redux/ActionsReducers/QuickSearchRedux';
 import { convertAdaptableStyleToCSS } from './StyleHelper';
-import kebabCase from '../utils/kebabCase';
+import { kebabCase } from '../Extensions/StringExtensions';
 const QUICK_SEARCH_FIND_CSS_KEYS = [
     'backgroundColor',
     'color',

package/src/Utilities/Helpers/{ScheduleHelper.d.ts → Scheduling/ScheduleHelper.d.ts}

@@ -1,4 +1,4 @@
-import { Schedule, Weekday } from '../../AdaptableState/Common/Schedule';
+import { Schedule, Weekday } from '../../../AdaptableState/Common/Schedule';
 export type ScheduleRecurrencePreset = 'daily' | 'weekdays' | 'selectedDays' | 'monthly' | 'custom';
 export declare function buildCronExpression(preset: ScheduleRecurrencePreset, hour: number, minute: number, options?: {
     days?: Weekday[];