@adaptabletools/adaptable-cjs 23.0.0-canary.8 → 23.0.0

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,10 @@ 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;
@@ -128,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);
             }
         }
     }
@@ -187,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) {
@@ -208,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;

package/src/Utilities/Helpers/Helper.js

@@ -12,9 +12,6 @@ exports.copyToClipboard = copyToClipboard;
 exports.returnItemCount = returnItemCount;
 exports.isInputNullOrEmpty = isInputNullOrEmpty;
 exports.isInputNotNullOrEmpty = isInputNotNullOrEmpty;
-exports.roundNumber = roundNumber;
-exports.roundNumberTo4dp = roundNumberTo4dp;
-exports.clamp = clamp;
 exports.extractColsFromText = extractColsFromText;
 exports.replaceAll = replaceAll;
 exports.extractContextKeysFromText = extractContextKeysFromText;
@@ -161,38 +158,6 @@ function isInputNullOrEmpty(itemToCheck) {
 function isInputNotNullOrEmpty(itemToCheck) {
     return !isInputNullOrEmpty(itemToCheck);
 }
-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;
-    }
-}
-function roundNumberTo4dp(numberToRound) {
-    return roundNumber(numberToRound, 4);
-}
-// putting this here to remove lodash clamp which seems to cause an issue
-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;
-}
 function extractColsFromText(text) {
     // rowData.columnName => columnName
     const regex = /\[rowData\.(.*?)\]/g;
@@ -233,9 +198,6 @@ exports.Helper = {
     returnItemCount,
     isInputNullOrEmpty,
     isInputNotNullOrEmpty,
-    roundNumber,
-    roundNumberTo4dp,
-    clamp,
     extractColsFromText,
     replaceAll,
     extractContextKeysFromText,

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

@@ -5,10 +5,9 @@ exports.resolveQuickSearchTextMatchStyle = resolveQuickSearchTextMatchStyle;
 exports.resolveQuickSearchCellMatchStyle = resolveQuickSearchCellMatchStyle;
 exports.resolveQuickSearchCurrentTextMatchStyle = resolveQuickSearchCurrentTextMatchStyle;
 exports.applyQuickSearchFindCssVars = applyQuickSearchFindCssVars;
-const tslib_1 = require("tslib");
 const QuickSearchRedux_1 = require("../../Redux/ActionsReducers/QuickSearchRedux");
 const StyleHelper_1 = require("./StyleHelper");
-const kebabCase_1 = tslib_1.__importDefault(require("../utils/kebabCase"));
+const StringExtensions_1 = require("../Extensions/StringExtensions");
 const QUICK_SEARCH_FIND_CSS_KEYS = [
     'backgroundColor',
     'color',
@@ -79,6 +78,6 @@ function applyQuickSearchFindCssVars(container, quickSearchState) {
 }
 function applyQuickSearchFindCssVarsForPrefix(container, prefix, css) {
     QUICK_SEARCH_FIND_CSS_KEYS.forEach((key) => {
-        container.style.setProperty(`--ab-qs-${prefix}-${(0, kebabCase_1.default)(key)}`, css[key] ?? '');
+        container.style.setProperty(`--ab-qs-${prefix}-${(0, StringExtensions_1.kebabCase)(key)}`, css[key] ?? '');
     });
 }

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[];

package/src/Utilities/Helpers/{ScheduleHelper.js → Scheduling/ScheduleHelper.js}

@@ -11,7 +11,7 @@ exports.getScheduleDescription = getScheduleDescription;
 exports.isValidCronExpression = isValidCronExpression;
 const tslib_1 = require("tslib");
 const cron_parser_1 = require("cron-parser");
-const StringExtensions_1 = tslib_1.__importDefault(require("../Extensions/StringExtensions"));
+const StringExtensions_1 = tslib_1.__importDefault(require("../../Extensions/StringExtensions"));
 const WEEKDAY_TO_CRON = {
     Sunday: 0,
     Monday: 1,

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

@@ -1,4 +1,4 @@
-import { Schedule } from '../../AdaptableState/Common/Schedule';
+import { Schedule } from '../../../AdaptableState/Common/Schedule';
 export interface ScheduleJobManagerConfig<T> {
     getActiveItems: () => T[];
     getSchedule: (item: T) => Schedule | undefined;

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

@@ -1,4 +1,4 @@
-import { Schedule } from '../../AdaptableState/Common/Schedule';
+import { Schedule } from '../../../AdaptableState/Common/Schedule';
 export interface ScheduleJob {
     cancel: () => void;
 }

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

@@ -1,4 +1,4 @@
-import { AlertButtonForm, AlertDefinition, RuleAlertProperties, RuleBasedAlertDefinition, ScheduledAlertDefinition } from '../../AdaptableState/AlertState';
+import { AlertButtonForm, AlertDefinition, RuleAlertProperties, RuleBasedAlertDefinition, ScheduledAlertDefinition } from '../../../AdaptableState/AlertState';
 export declare function isScheduledAlertDefinition(alert: AlertDefinition | undefined | null): alert is ScheduledAlertDefinition;
 export declare function isRuleBasedAlertDefinition(alert: AlertDefinition | undefined | null): alert is RuleBasedAlertDefinition;
 export declare function getRuleAlertProperties(alert: AlertDefinition | undefined | null): RuleAlertProperties | undefined;