@adaptabletools/adaptable-cjs 22.0.0-canary.11 → 22.0.0-canary.13

package/src/Utilities/utils/flatten.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = flatten;
+/**
+ * Flattens array a single level deep.
+ * Drop-in replacement for lodash/flatten.
+ */
+function flatten(array) {
+    return array.flat();
+}

package/src/Utilities/utils/flattenDeep.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Recursively flattens array.
+ * Drop-in replacement for lodash/flattenDeep.
+ */
+export default function flattenDeep<T>(array: any[]): T[];

package/src/Utilities/utils/flattenDeep.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = flattenDeep;
+/**
+ * Recursively flattens array.
+ * Drop-in replacement for lodash/flattenDeep.
+ */
+function flattenDeep(array) {
+    return array.flat(Infinity);
+}

package/src/Utilities/utils/get.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Gets the value at path of object. If the resolved value is undefined,
+ * the defaultValue is returned in its place.
+ * Drop-in replacement for lodash/get.
+ */
+export default function get(object: any, path: string | string[], defaultValue?: any): any;

package/src/Utilities/utils/get.js

@@ -0,0 +1,38 @@
+"use strict";
+/**
+ * Gets the value at path of object. If the resolved value is undefined,
+ * the defaultValue is returned in its place.
+ * Drop-in replacement for lodash/get.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = get;
+const rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
+function toPath(path) {
+    if (Array.isArray(path)) {
+        return path;
+    }
+    const result = [];
+    const str = String(path);
+    str.replace(rePropName, (match, number, quote, subString) => {
+        result.push(quote ? subString.replace(/\\(\\)?/g, '$1') : number || match);
+        return match;
+    });
+    return result;
+}
+function get(object, path, defaultValue) {
+    if (typeof path === 'string' && path === '') {
+        return defaultValue;
+    }
+    const keys = toPath(path);
+    if (keys.length === 0) {
+        return defaultValue;
+    }
+    let result = object;
+    for (const key of keys) {
+        if (result == null) {
+            return defaultValue;
+        }
+        result = result[key];
+    }
+    return result === undefined ? defaultValue : result;
+}

package/src/Utilities/utils/index.d.ts

@@ -0,0 +1,22 @@
+export { default as chunk } from './chunk';
+export { default as clamp } from './clamp';
+export { default as cloneDeepWith } from './cloneDeepWith';
+export { default as debounce } from './debounce';
+export { default as flatten } from './flatten';
+export { default as flattenDeep } from './flattenDeep';
+export { default as get } from './get';
+export { default as isArray } from './isArray';
+export { default as isEqual } from './isEqual';
+export { default as isObject } from './isObject';
+export { default as isPlainObject } from './isPlainObject';
+export { default as kebabCase } from './kebabCase';
+export { default as merge } from './merge';
+export { default as mergeWith } from './mergeWith';
+export { default as orderBy } from './orderBy';
+export { default as parseInt } from './parseInt';
+export { default as sentenceCase } from './sentenceCase';
+export { default as startCase } from './startCase';
+export { default as throttle } from './throttle';
+export { default as toNumber } from './toNumber';
+export { default as uniq } from './uniq';
+export { default as uniqBy } from './uniqBy';

package/src/Utilities/utils/index.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uniqBy = exports.uniq = exports.toNumber = exports.throttle = exports.startCase = exports.sentenceCase = exports.parseInt = exports.orderBy = exports.mergeWith = exports.merge = exports.kebabCase = exports.isPlainObject = exports.isObject = exports.isEqual = exports.isArray = exports.get = exports.flattenDeep = exports.flatten = exports.debounce = exports.cloneDeepWith = exports.clamp = exports.chunk = void 0;
+const tslib_1 = require("tslib");
+var chunk_1 = require("./chunk");
+Object.defineProperty(exports, "chunk", { enumerable: true, get: function () { return tslib_1.__importDefault(chunk_1).default; } });
+var clamp_1 = require("./clamp");
+Object.defineProperty(exports, "clamp", { enumerable: true, get: function () { return tslib_1.__importDefault(clamp_1).default; } });
+var cloneDeepWith_1 = require("./cloneDeepWith");
+Object.defineProperty(exports, "cloneDeepWith", { enumerable: true, get: function () { return tslib_1.__importDefault(cloneDeepWith_1).default; } });
+var debounce_1 = require("./debounce");
+Object.defineProperty(exports, "debounce", { enumerable: true, get: function () { return tslib_1.__importDefault(debounce_1).default; } });
+var flatten_1 = require("./flatten");
+Object.defineProperty(exports, "flatten", { enumerable: true, get: function () { return tslib_1.__importDefault(flatten_1).default; } });
+var flattenDeep_1 = require("./flattenDeep");
+Object.defineProperty(exports, "flattenDeep", { enumerable: true, get: function () { return tslib_1.__importDefault(flattenDeep_1).default; } });
+var get_1 = require("./get");
+Object.defineProperty(exports, "get", { enumerable: true, get: function () { return tslib_1.__importDefault(get_1).default; } });
+var isArray_1 = require("./isArray");
+Object.defineProperty(exports, "isArray", { enumerable: true, get: function () { return tslib_1.__importDefault(isArray_1).default; } });
+var isEqual_1 = require("./isEqual");
+Object.defineProperty(exports, "isEqual", { enumerable: true, get: function () { return tslib_1.__importDefault(isEqual_1).default; } });
+var isObject_1 = require("./isObject");
+Object.defineProperty(exports, "isObject", { enumerable: true, get: function () { return tslib_1.__importDefault(isObject_1).default; } });
+var isPlainObject_1 = require("./isPlainObject");
+Object.defineProperty(exports, "isPlainObject", { enumerable: true, get: function () { return tslib_1.__importDefault(isPlainObject_1).default; } });
+var kebabCase_1 = require("./kebabCase");
+Object.defineProperty(exports, "kebabCase", { enumerable: true, get: function () { return tslib_1.__importDefault(kebabCase_1).default; } });
+var merge_1 = require("./merge");
+Object.defineProperty(exports, "merge", { enumerable: true, get: function () { return tslib_1.__importDefault(merge_1).default; } });
+var mergeWith_1 = require("./mergeWith");
+Object.defineProperty(exports, "mergeWith", { enumerable: true, get: function () { return tslib_1.__importDefault(mergeWith_1).default; } });
+var orderBy_1 = require("./orderBy");
+Object.defineProperty(exports, "orderBy", { enumerable: true, get: function () { return tslib_1.__importDefault(orderBy_1).default; } });
+var parseInt_1 = require("./parseInt");
+Object.defineProperty(exports, "parseInt", { enumerable: true, get: function () { return tslib_1.__importDefault(parseInt_1).default; } });
+var sentenceCase_1 = require("./sentenceCase");
+Object.defineProperty(exports, "sentenceCase", { enumerable: true, get: function () { return tslib_1.__importDefault(sentenceCase_1).default; } });
+var startCase_1 = require("./startCase");
+Object.defineProperty(exports, "startCase", { enumerable: true, get: function () { return tslib_1.__importDefault(startCase_1).default; } });
+var throttle_1 = require("./throttle");
+Object.defineProperty(exports, "throttle", { enumerable: true, get: function () { return tslib_1.__importDefault(throttle_1).default; } });
+var toNumber_1 = require("./toNumber");
+Object.defineProperty(exports, "toNumber", { enumerable: true, get: function () { return tslib_1.__importDefault(toNumber_1).default; } });
+var uniq_1 = require("./uniq");
+Object.defineProperty(exports, "uniq", { enumerable: true, get: function () { return tslib_1.__importDefault(uniq_1).default; } });
+var uniqBy_1 = require("./uniqBy");
+Object.defineProperty(exports, "uniqBy", { enumerable: true, get: function () { return tslib_1.__importDefault(uniqBy_1).default; } });

package/src/Utilities/utils/isArray.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Checks if value is classified as an Array object.
+ * Drop-in replacement for lodash/isArray.
+ */
+declare const isArray: (value: any) => value is any[];
+export default isArray;

package/src/Utilities/utils/isArray.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Checks if value is classified as an Array object.
+ * Drop-in replacement for lodash/isArray.
+ */
+const isArray = Array.isArray;
+exports.default = isArray;

package/src/Utilities/utils/isEqual.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Performs a deep comparison between two values to determine if they are equivalent.
+ * Drop-in replacement for lodash/isEqual.
+ */
+export default function isEqual(value: any, other: any): boolean;

package/src/Utilities/utils/isEqual.js

@@ -0,0 +1,127 @@
+"use strict";
+/**
+ * Performs a deep comparison between two values to determine if they are equivalent.
+ * Drop-in replacement for lodash/isEqual.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = isEqual;
+function baseIsEqual(a, b, seen) {
+    // Identical references or primitives
+    if (a === b) {
+        return true;
+    }
+    // NaN check
+    if (a !== a && b !== b) {
+        return true;
+    }
+    // Null/undefined/primitive mismatch
+    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;
+    }
+    // Date
+    if (a instanceof Date && b instanceof Date) {
+        return a.getTime() === b.getTime();
+    }
+    // RegExp
+    if (a instanceof RegExp && b instanceof RegExp) {
+        return a.source === b.source && a.flags === b.flags;
+    }
+    // One is Date/RegExp but the other is not
+    if (a instanceof Date !== b instanceof Date) {
+        return false;
+    }
+    if (a instanceof RegExp !== b instanceof RegExp) {
+        return false;
+    }
+    // Circular reference detection
+    if (seen.has(a)) {
+        return seen.get(a) === b;
+    }
+    seen.set(a, b);
+    // Arrays
+    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;
+    }
+    // Map
+    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;
+    }
+    // Set (unordered deep comparison, matching lodash behavior)
+    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;
+    }
+    // ArrayBuffer / TypedArray
+    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;
+    }
+    // Plain objects
+    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;
+}
+function isEqual(value, other) {
+    return baseIsEqual(value, other, new Map());
+}

package/src/Utilities/utils/isObject.d.ts

@@ -0,0 +1,6 @@
+/**
+ * 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 default function isObject(value: any): value is object;

package/src/Utilities/utils/isObject.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = isObject;
+/**
+ * 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');
+}

package/src/Utilities/utils/isPlainObject.d.ts

@@ -0,0 +1,6 @@
+/**
+ * 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 default function isPlainObject(value: any): value is Record<string, any>;

package/src/Utilities/utils/isPlainObject.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = isPlainObject;
+/**
+ * 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);
+    // Object.create(null)
+    if (proto === null) {
+        return true;
+    }
+    // Normal plain objects
+    return proto === Object.prototype;
+}

package/src/Utilities/utils/kebabCase.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Converts string to kebab-case.
+ * Drop-in replacement for lodash/kebabCase.
+ */
+export default function kebabCase(string: string): string;

package/src/Utilities/utils/kebabCase.js

@@ -0,0 +1,12 @@
+"use strict";
+/**
+ * Converts string to kebab-case.
+ * Drop-in replacement for lodash/kebabCase.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = kebabCase;
+const tslib_1 = require("tslib");
+const words_1 = tslib_1.__importDefault(require("./words"));
+function kebabCase(string) {
+    return (0, words_1.default)(string).map((w) => w.toLowerCase()).join('-');
+}

package/src/Utilities/utils/merge.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Recursively merges own enumerable string keyed properties of source objects into
+ * the destination object. Source properties that resolve to undefined are skipped if
+ * a destination value exists. Array and plain object properties are merged recursively.
+ * Other objects and value types are overridden by assignment.
+ * Drop-in replacement for lodash/merge.
+ */
+export default function merge<TObject, TSource1>(object: TObject, source1: TSource1): TObject & TSource1;
+export default function merge<TObject, TSource1, TSource2>(object: TObject, source1: TSource1, source2: TSource2): TObject & TSource1 & TSource2;
+export default function merge<TObject, TSource1, TSource2, TSource3>(object: TObject, source1: TSource1, source2: TSource2, source3: TSource3): TObject & TSource1 & TSource2 & TSource3;
+export default function merge(target: any, ...sources: any[]): any;

package/src/Utilities/utils/merge.js

@@ -0,0 +1,44 @@
+"use strict";
+/**
+ * Recursively merges own enumerable string keyed properties of source objects into
+ * the destination object. Source properties that resolve to undefined are skipped if
+ * a destination value exists. Array and plain object properties are merged recursively.
+ * Other objects and value types are overridden by assignment.
+ * Drop-in replacement for lodash/merge.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = merge;
+const tslib_1 = require("tslib");
+const isPlainObject_1 = tslib_1.__importDefault(require("./isPlainObject"));
+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 ((0, isPlainObject_1.default)(srcValue)) {
+            if (!(0, isPlainObject_1.default)(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;
+}

package/src/Utilities/utils/mergeWith.d.ts

@@ -0,0 +1,7 @@
+/**
+ * This method is like `merge` except that it accepts customizer which is
+ * invoked to produce the merged values of the destination and source properties.
+ * If customizer returns undefined, merging is handled by the method instead.
+ * Drop-in replacement for lodash/mergeWith.
+ */
+export default function mergeWith<T extends object>(target: T, ...args: any[]): T;

package/src/Utilities/utils/mergeWith.js

@@ -0,0 +1,50 @@
+"use strict";
+/**
+ * This method is like `merge` except that it accepts customizer which is
+ * invoked to produce the merged values of the destination and source properties.
+ * If customizer returns undefined, merging is handled by the method instead.
+ * Drop-in replacement for lodash/mergeWith.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = mergeWith;
+const tslib_1 = require("tslib");
+const isPlainObject_1 = tslib_1.__importDefault(require("./isPlainObject"));
+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 ((0, isPlainObject_1.default)(srcValue)) {
+            if (!(0, isPlainObject_1.default)(tgtValue)) {
+                target[key] = {};
+            }
+            baseMergeWith(target[key], srcValue, customizer);
+        }
+        else if (srcValue !== undefined) {
+            target[key] = srcValue;
+        }
+    }
+    return target;
+}
+function mergeWith(target, ...args) {
+    // The last argument is the customizer function
+    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/utils/orderBy.d.ts

@@ -0,0 +1,8 @@
+/**
+ * This method is like `sortBy` except that it allows specifying the sort
+ * orders of the iteratees to sort by. If orders is unspecified, all values
+ * are sorted in ascending order. Otherwise, specify an order of "desc" for
+ * descending or "asc" for ascending sort order of corresponding values.
+ * Drop-in replacement for lodash/orderBy.
+ */
+export default function orderBy<T>(collection: T[], iteratees: ((item: T) => any)[] | string[], orders?: ('asc' | 'desc')[]): T[];

package/src/Utilities/utils/orderBy.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = orderBy;
+/**
+ * This method is like `sortBy` except that it allows specifying the sort
+ * orders of the iteratees to sort by. If orders is unspecified, all values
+ * are sorted in ascending order. Otherwise, specify an order of "desc" for
+ * descending or "asc" for ascending sort order of corresponding values.
+ * Drop-in replacement for lodash/orderBy.
+ */
+function orderBy(collection, iteratees, orders) {
+    const result = [...collection];
+    const fns = iteratees.map((iteratee) => typeof iteratee === 'function' ? iteratee : (item) => item?.[iteratee]);
+    result.sort((a, b) => {
+        for (let i = 0; i < fns.length; i++) {
+            const valA = fns[i](a);
+            const valB = fns[i](b);
+            if (valA !== valB) {
+                const order = orders?.[i] === 'desc' ? -1 : 1;
+                if (valA == null)
+                    return 1;
+                if (valB == null)
+                    return -1;
+                if (valA < valB)
+                    return -order;
+                if (valA > valB)
+                    return order;
+            }
+        }
+        return 0;
+    });
+    return result;
+}

package/src/Utilities/utils/parseInt.d.ts

@@ -0,0 +1,6 @@
+/**
+ * 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 default function parseIntFn(string: string, radix?: number): number;

package/src/Utilities/utils/parseInt.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = parseIntFn;
+/**
+ * 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.
+ */
+function parseIntFn(string, radix) {
+    const str = typeof string === 'string' ? string.trim() : String(string);
+    return globalThis.parseInt(str, radix || 10);
+}

package/src/Utilities/utils/sentenceCase.d.ts

@@ -0,0 +1,6 @@
+/**
+ * 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 default function sentenceCase(input: string): string;

package/src/Utilities/utils/sentenceCase.js

@@ -0,0 +1,19 @@
+"use strict";
+/**
+ * Converts string to Sentence case.
+ * Splits on camelCase, PascalCase, dots, underscores, hyphens, and non-alphanumeric characters.
+ * Drop-in replacement for the sentence-case package.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = sentenceCase;
+const tslib_1 = require("tslib");
+const words_1 = tslib_1.__importDefault(require("./words"));
+function sentenceCase(input) {
+    const parts = (0, words_1.default)(input);
+    if (parts.length === 0) {
+        return '';
+    }
+    return parts
+        .map((w, i) => (i === 0 ? w.charAt(0).toUpperCase() + w.slice(1).toLowerCase() : w.toLowerCase()))
+        .join(' ');
+}

package/src/Utilities/utils/startCase.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Converts string to Start Case.
+ * Drop-in replacement for lodash/startCase.
+ */
+export default function startCase(string: string): string;

package/src/Utilities/utils/startCase.js

@@ -0,0 +1,15 @@
+"use strict";
+/**
+ * Converts string to Start Case.
+ * Drop-in replacement for lodash/startCase.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = startCase;
+const tslib_1 = require("tslib");
+const words_1 = tslib_1.__importDefault(require("./words"));
+function capitalize(word) {
+    return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
+}
+function startCase(string) {
+    return (0, words_1.default)(string).map(capitalize).join(' ');
+}

package/src/Utilities/utils/throttle.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Creates a throttled function that only invokes func at most once per
+ * every wait milliseconds. The throttled function comes with a cancel
+ * method to cancel delayed func invocations and a flush method to
+ * immediately invoke them.
+ *
+ * Supports options: { leading, trailing }
+ * Drop-in replacement for lodash/throttle.
+ *
+ * Implemented using debounce with maxWait (same approach as lodash).
+ */
+import { DebouncedFunction } from './debounce';
+export interface ThrottleOptions {
+    leading?: boolean;
+    trailing?: boolean;
+}
+export default function throttle<T extends (...args: any[]) => any>(func: T, wait?: number, options?: ThrottleOptions): DebouncedFunction<T>;

package/src/Utilities/utils/throttle.js

@@ -0,0 +1,23 @@
+"use strict";
+/**
+ * Creates a throttled function that only invokes func at most once per
+ * every wait milliseconds. The throttled function comes with a cancel
+ * method to cancel delayed func invocations and a flush method to
+ * immediately invoke them.
+ *
+ * Supports options: { leading, trailing }
+ * Drop-in replacement for lodash/throttle.
+ *
+ * Implemented using debounce with maxWait (same approach as lodash).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = throttle;
+const tslib_1 = require("tslib");
+const debounce_1 = tslib_1.__importDefault(require("./debounce"));
+function throttle(func, wait = 0, options) {
+    return (0, debounce_1.default)(func, wait, {
+        leading: options?.leading ?? true,
+        trailing: options?.trailing ?? true,
+        maxWait: wait,
+    });
+}

package/src/Utilities/utils/toNumber.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Converts value to a number.
+ * Drop-in replacement for lodash/toNumber.
+ */
+export default function toNumber(value: any): number;