@augment-vir/common 4.6.1 → 5.0.1

package/dist/esm/augments/object.js

@@ -0,0 +1,252 @@
+import { extractErrorMessage } from './error';
+import { isTruthy } from './function';
+export function getEnumTypedKeys(input) {
+    // enum keys are always strings
+    return getObjectTypedKeys(input).filter((key) => isNaN(Number(key)));
+}
+export function getEnumTypedValues(input) {
+    const keys = getEnumTypedKeys(input);
+    return keys.map((key) => input[key]);
+}
+export function isEnumValue(input, checkEnum) {
+    return getEnumTypedValues(checkEnum).includes(input);
+}
+export function isKeyof(key, object) {
+    return typedHasProperty(object, key);
+}
+export function filterToEnumValues(inputs, checkEnum, caseInsensitive = false) {
+    if (caseInsensitive) {
+        return inputs.reduce((accum, currentInput) => {
+            const matchedEnumValue = getEnumTypedValues(checkEnum).find((actualEnumValue) => {
+                return String(actualEnumValue).toUpperCase() === String(currentInput).toUpperCase();
+            });
+            if (matchedEnumValue) {
+                return accum.concat(matchedEnumValue);
+            }
+            else {
+                return accum;
+            }
+        }, []);
+    }
+    else {
+        return inputs.filter((input) => isEnumValue(input, checkEnum));
+    }
+}
+export function getObjectTypedKeys(input) {
+    let reflectKeys;
+    try {
+        reflectKeys = Reflect.ownKeys(input);
+    }
+    catch (error) { }
+    return (reflectKeys !== null && reflectKeys !== void 0 ? reflectKeys : [
+        ...Object.keys(input),
+        ...Object.getOwnPropertySymbols(input),
+    ]);
+}
+export function getObjectTypedValues(input) {
+    return getObjectTypedKeys(input).map((key) => input[key]);
+}
+const hasPropertyAttempts = [
+    (object, key) => {
+        return key in object;
+    },
+    (object, key) => {
+        /** This handles cases where the input object can't use `in` directly, like string literals */
+        return key in object.constructor.prototype;
+    },
+];
+export function typedHasProperty(inputObject, inputKey) {
+    if (!inputObject) {
+        return false;
+    }
+    return hasPropertyAttempts.some((attemptCallback) => {
+        try {
+            return attemptCallback(inputObject, inputKey);
+        }
+        catch (error) {
+            return false;
+        }
+    });
+}
+export function typedHasProperties(inputObject, inputKeys) {
+    return inputObject && inputKeys.every((key) => typedHasProperty(inputObject, key));
+}
+export function isObject(input) {
+    return !!input && typeof input === 'object';
+}
+export function getEntriesSortedByKey(input) {
+    return Object.entries(input).sort((tupleA, tupleB) => tupleA[0].localeCompare(tupleB[0]));
+}
+export function areJsonEqual(a, b) {
+    try {
+        const sortedAEntries = getEntriesSortedByKey(a);
+        const sortedBEntries = getEntriesSortedByKey(b);
+        return JSON.stringify(sortedAEntries) === JSON.stringify(sortedBEntries);
+    }
+    catch (error) {
+        console.error(`Failed to compare objects using JSON.stringify`);
+        throw error;
+    }
+}
+/**
+ * Creates a new object with the same properties as the input object, but with values set to the
+ * result of mapCallback for each property.
+ */
+export function mapObjectValues(inputObject, mapCallback) {
+    let gotAPromise = false;
+    const mappedObject = getObjectTypedKeys(inputObject).reduce((accum, currentKey) => {
+        const mappedValue = mapCallback(currentKey, inputObject[currentKey], inputObject);
+        if (mappedValue instanceof Promise) {
+            gotAPromise = true;
+        }
+        return {
+            ...accum,
+            [currentKey]: mappedValue,
+        };
+    }, {});
+    if (gotAPromise) {
+        return new Promise(async (resolve, reject) => {
+            try {
+                await Promise.all(getObjectTypedKeys(mappedObject).map(async (key) => {
+                    const value = await mappedObject[key];
+                    mappedObject[key] = value;
+                }));
+                resolve(mappedObject);
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+    else {
+        return mappedObject;
+    }
+}
+export function filterObject(inputObject, callback) {
+    const filteredKeys = getObjectTypedKeys(inputObject).filter((key) => {
+        const value = inputObject[key];
+        return callback(key, value, inputObject);
+    });
+    return filteredKeys.reduce((accum, key) => {
+        accum[key] = inputObject[key];
+        return accum;
+    }, {});
+}
+/** The input here must be serializable otherwise JSON parsing errors will be thrown */
+export function copyThroughJson(input) {
+    try {
+        return JSON.parse(JSON.stringify(input));
+    }
+    catch (error) {
+        console.error(`Failed to JSON copy for`, input);
+        throw error;
+    }
+}
+/**
+ * Checks that the first input, testThisOne, matches the object shape of the second input,
+ * compareToThisOne. Does not compare exact values of properties, only types.
+ *
+ * To allow the test input, the first input, to have additional keys that the compare input, the
+ * second input, does not have, pass in a third argument set to true.
+ *
+ * This function REQUIRES a generic to be assigned to it: it cannot infer it from the inputs.
+ *
+ * The compare input, the second input, is required to have at least one entry in every array value
+ * that exists. If more array values are present, they will be considered other possible types for
+ * entries in that array.
+ */
+export function matchesObjectShape(testThisOne, compareToThisOne, allowExtraProps = false, shouldLogWhy = false) {
+    try {
+        assertMatchesObjectShape(testThisOne, compareToThisOne, allowExtraProps);
+        return true;
+    }
+    catch (error) {
+        if (shouldLogWhy) {
+            console.error(error);
+        }
+        return false;
+    }
+}
+/**
+ * Asserts that the first input, testThisOne, matches the object shape of the second input,
+ * compareToThisOne. Does not compare exact values of properties, only types.
+ *
+ * To allow the test input, the first input, to have additional keys that the compare input, the
+ * second input, does not have, pass in a third argument set to true.
+ *
+ * This function REQUIRES a generic to be assigned to it: it cannot infer it from the inputs.
+ *
+ * The compare input, the second input, is required to have at least one entry in every array value
+ * that exists. If more array values are present, they will be considered other possible types for
+ * entries in that array.
+ */
+export function assertMatchesObjectShape(testThisOne, compareToThisOne, allowExtraProps = false) {
+    const testKeys = getObjectTypedKeys(testThisOne);
+    const matchKeys = new Set(getObjectTypedKeys(compareToThisOne));
+    if (!allowExtraProps) {
+        const extraKeys = testKeys.filter((testKey) => !matchKeys.has(testKey));
+        if (extraKeys.length) {
+            throw new Error(`Test object has extra keys: ${extraKeys.join(', ')}`);
+        }
+    }
+    matchKeys.forEach((key) => {
+        if (!typedHasProperty(testThisOne, key)) {
+            throw new Error(`test object does not have key "${String(key)}" from expected shape.`);
+        }
+        function throwKeyError(reason) {
+            throw new Error(`test object value at key "${String(key)}" did not match expected shape: ${reason}`);
+        }
+        const testValue = testThisOne[key];
+        const shouldMatch = compareToThisOne[key];
+        compareInnerValue(testValue, shouldMatch, throwKeyError);
+    });
+}
+function compareInnerValue(testValue, matchValue, throwKeyError) {
+    var _a;
+    const testType = typeof testValue;
+    const shouldMatchType = typeof matchValue;
+    if (testType !== shouldMatchType) {
+        throwKeyError(`type "${testType}" did not match expected type "${shouldMatchType}"`);
+    }
+    try {
+        if (typedHasProperty(matchValue, 'constructor')) {
+            if (!typedHasProperty(testValue, 'constructor') ||
+                testValue.constructor !== matchValue.constructor) {
+                throwKeyError(`constructor "${(_a = testValue === null || testValue === void 0 ? void 0 : testValue.constructor) === null || _a === void 0 ? void 0 : _a.name}" did not match expected constructor "${matchValue.constructor}"`);
+            }
+        }
+    }
+    catch (error) {
+        // ignore errors from trying to find the constructor
+        if (error instanceof throwKeyError) {
+            throw error;
+        }
+    }
+    if (Array.isArray(matchValue)) {
+        if (!Array.isArray(testValue)) {
+            throwKeyError(`expected an array`);
+        }
+        testValue.forEach((testValueEntry, index) => {
+            const errors = matchValue
+                .map((matchValue) => {
+                try {
+                    compareInnerValue(testValueEntry, matchValue, throwKeyError);
+                    return undefined;
+                }
+                catch (error) {
+                    return new Error(`entry at index "${index}" did not match expected shape: ${extractErrorMessage(error)}`);
+                }
+            })
+                .filter(isTruthy);
+            if (errors.length === matchValue.length) {
+                throw new Error(`entry at index "${index}" did not match any of the possible types from "${matchValue.join(', ')}"`);
+            }
+        });
+    }
+    else if (isObject(matchValue)) {
+        assertMatchesObjectShape(testValue, matchValue);
+    }
+}
+export function typedObjectFromEntries(entries) {
+    return Object.fromEntries(entries);
+}

package/dist/esm/augments/promise.d.ts

@@ -0,0 +1,23 @@
+export declare function wait(delayMs: number): Promise<void>;
+export declare function isPromiseLike<T>(input: T | unknown): input is T extends PromiseLike<infer ValueType> ? PromiseLike<ValueType> : PromiseLike<unknown>;
+export declare class PromiseTimeoutError extends Error {
+    readonly durationMs: number;
+    readonly message: string;
+    readonly name = "PromiseTimeoutError";
+    constructor(durationMs: number, message?: string);
+}
+export declare function wrapPromiseInTimeout<PromiseValueType>(durationMs: number, originalPromise: PromiseLike<PromiseValueType>): Promise<PromiseValueType>;
+/** A promise which can be resolved or rejected by external code. */
+export declare type DeferredPromiseWrapper<T> = {
+    promise: Promise<T>;
+    resolve: (value: T | PromiseLike<T>) => void;
+    reject: (reason?: any) => void;
+};
+export declare function createDeferredPromiseWrapper<T = void>(): DeferredPromiseWrapper<T>;
+export declare type WaitForConditionInputs = {
+    conditionCallback: () => boolean | Promise<boolean>;
+    timeoutMs?: number;
+    intervalMs?: number;
+    timeoutMessage?: string;
+};
+export declare function waitForCondition({ conditionCallback, timeoutMs, intervalMs, timeoutMessage, }: WaitForConditionInputs): Promise<void>;

package/dist/esm/augments/promise.js

@@ -0,0 +1,84 @@
+import { extractErrorMessage } from './error';
+import { typedHasProperty } from './object';
+export function wait(delayMs) {
+    const deferredPromiseWrapper = createDeferredPromiseWrapper();
+    if (delayMs === Infinity || delayMs < 0) {
+        return deferredPromiseWrapper.promise;
+    }
+    setTimeout(() => {
+        deferredPromiseWrapper.resolve();
+    }, delayMs);
+    return deferredPromiseWrapper.promise;
+}
+export function isPromiseLike(input) {
+    if (typedHasProperty(input, 'then') && typeof input.then === 'function') {
+        return true;
+    }
+    else {
+        return false;
+    }
+}
+export class PromiseTimeoutError extends Error {
+    constructor(durationMs, message = `Promised timed out after ${durationMs} ms.`) {
+        super(message);
+        this.durationMs = durationMs;
+        this.message = message;
+        this.name = 'PromiseTimeoutError';
+    }
+}
+export function wrapPromiseInTimeout(durationMs, originalPromise) {
+    return new Promise(async (resolve, reject) => {
+        const timeoutId = setTimeout(() => {
+            reject(new PromiseTimeoutError(durationMs));
+        }, durationMs);
+        try {
+            const result = await originalPromise;
+            resolve(result);
+        }
+        catch (error) {
+            reject(error);
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+    });
+}
+export function createDeferredPromiseWrapper() {
+    let resolve;
+    let reject;
+    const promise = new Promise((resolveCallback, rejectCallback) => {
+        resolve = resolveCallback;
+        reject = rejectCallback;
+    });
+    if (!resolve || !reject) {
+        throw new Error(`Reject and resolve callbacks were not set by the promise constructor for ${createDeferredPromiseWrapper.name}.`);
+    }
+    return {
+        promise,
+        resolve,
+        reject,
+    };
+}
+export async function waitForCondition({ conditionCallback, timeoutMs = 10000, intervalMs = 100, timeoutMessage = '', }) {
+    let condition = false;
+    let lastError;
+    async function checkCondition() {
+        try {
+            condition = !!(await conditionCallback());
+        }
+        catch (error) {
+            condition = false;
+            lastError = error;
+        }
+    }
+    const startTime = Date.now();
+    await checkCondition();
+    while (!condition) {
+        await wait(intervalMs);
+        if (Date.now() - startTime >= timeoutMs) {
+            const message = timeoutMessage ? `${timeoutMessage}: ` : '';
+            throw new Error(`${message}Timeout of "${timeoutMs}" exceeded waiting for condition to be true${extractErrorMessage(lastError)}`);
+        }
+        await checkCondition();
+    }
+}

package/dist/esm/augments/regexp.d.ts

@@ -0,0 +1,3 @@
+export declare function deDupeRegExFlags(flags: string): string;
+export declare function addRegExpFlags(originalRegExp: RegExp, flags: string): RegExp;
+export declare function safeMatch(input: string, regExp: RegExp): string[];

package/dist/esm/augments/regexp.js

@@ -0,0 +1,14 @@
+export function deDupeRegExFlags(flags) {
+    const deDuped = new Set(Array.from(flags.toLowerCase()));
+    return Array.from(deDuped).join('');
+}
+export function addRegExpFlags(originalRegExp, flags) {
+    return new RegExp(originalRegExp.source, deDupeRegExFlags([
+        originalRegExp.flags,
+        flags,
+    ].join('')));
+}
+export function safeMatch(input, regExp) {
+    const match = input.match(regExp);
+    return match !== null && match !== void 0 ? match : [];
+}

package/dist/esm/augments/tuple.d.ts

@@ -0,0 +1,8 @@
+export declare type Tuple<ArrayElementGeneric, LengthGeneric extends number> = LengthGeneric extends LengthGeneric ? number extends LengthGeneric ? ArrayElementGeneric[] : _TupleOf<ArrayElementGeneric, LengthGeneric, []> : never;
+declare type _TupleOf<ArrayElementGeneric, LengthGeneric extends number, FullArrayGeneric extends unknown[]> = FullArrayGeneric['length'] extends LengthGeneric ? FullArrayGeneric : _TupleOf<ArrayElementGeneric, LengthGeneric, [ArrayElementGeneric, ...FullArrayGeneric]>;
+export declare type AtLeastTuple<ArrayElementGeneric, LengthGeneric extends number> = readonly [
+    ...Tuple<ArrayElementGeneric, LengthGeneric>,
+    ...ArrayElementGeneric[]
+];
+export declare function isLengthAtLeast<ArrayElementGeneric, LengthGeneric extends number>(array: ReadonlyArray<ArrayElementGeneric>, length: LengthGeneric): array is AtLeastTuple<ArrayElementGeneric, LengthGeneric>;
+export {};

package/dist/esm/augments/tuple.js

@@ -0,0 +1,3 @@
+export function isLengthAtLeast(array, length) {
+    return array.length >= length;
+}

package/dist/esm/augments/type-of.d.ts

@@ -0,0 +1,17 @@
+declare function getTypeOf(x: any): "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
+export declare type TypeOf = ReturnType<typeof getTypeOf>;
+export declare type TypeOfWithArray = TypeOf | 'array';
+export declare type TypeOfMapping = {
+    array: any[];
+    bigint: bigint;
+    boolean: boolean;
+    function: (...args: any[]) => any;
+    number: number;
+    object: object;
+    string: string;
+    symbol: symbol;
+    undefined: undefined;
+};
+export declare function typeOfWithArray(input: unknown): TypeOfWithArray;
+export declare function isTypeOfWithArray<T extends TypeOfWithArray>(input: unknown, testType: T): input is TypeOfMapping[T];
+export {};

package/dist/esm/augments/type-of.js

@@ -0,0 +1,12 @@
+// this function is not used at run time, it's only here for types
+// istanbul ignore next
+function getTypeOf(x) {
+    return typeof x;
+}
+export function typeOfWithArray(input) {
+    return Array.isArray(input) ? 'array' : typeof input;
+}
+export function isTypeOfWithArray(input, testType) {
+    const inputType = typeOfWithArray(input);
+    return inputType === testType;
+}

package/dist/esm/augments/type.d.ts

@@ -0,0 +1,54 @@
+/** Makes all properties in an object writable. This is the opposite of Readonly<> */
+export declare type Writeable<T> = {
+    -readonly [P in keyof T]: T[P];
+};
+/** Makes all property values in an object also readonly. Can cause issues on primitive. */
+export declare type DeepWriteable<T> = {
+    -readonly [P in keyof T]: DeepWriteable<T[P]>;
+};
+/** Replace properties in T with properties in U. */
+export declare type Overwrite<T, U> = Pick<T, Exclude<keyof T, keyof U>> & U;
+/** Extract the element type out of an array type. */
+export declare type ArrayElement<ArrayType extends ReadonlyArray<any>> = ArrayType[number];
+/**
+ * Same as the Required<> built-in type helper but this requires that each property be present and
+ * be not null.
+ */
+export declare type RequiredAndNotNull<T> = {
+    [P in keyof T]-?: NonNullable<T[P]>;
+};
+/** Require only a subset of object properties. */
+export declare type RequiredBy<T, K extends keyof T> = Overwrite<T, Required<Pick<T, K>>>;
+/**
+ * Require only a subset of object properties and require that they be not null. This is
+ * particularly useful in conjunction with the "exactOptionalPropertyTypes" tsconfig flag.
+ */
+export declare type RequiredAndNotNullBy<T, K extends keyof T> = Omit<T, K> & Required<{
+    [PropertyName in K]: NonNullable<T[PropertyName]>;
+}>;
+/** If type T = type U, then type Y. Else type N. */
+export declare type IfEquals<T, U, Y = unknown, N = never> = (<G>() => G extends T ? 1 : 2) extends <G>() => G extends U ? 1 : 2 ? Y : N;
+export declare type UnPromise<T> = T extends PromiseLike<infer PromiseType> ? Awaited<PromiseType> : T;
+/**
+ * This function returns another function that simply returns whatever input it's given. However, it
+ * also checks that the input matches the original wrapNarrowTypeWithTypeCheck's generic, while
+ * maintaining strict "const" like typing.
+ *
+ * Use like this: wrapNarrowTypeWithTypeCheck<EnforcedTypeHere>()(valueToEnforceTypeOn as const)
+ *
+ * Sometimes "as const" isn't required, usually it is for any object or array though.
+ */
+export declare function wrapNarrowTypeWithTypeCheck<P>(): <T extends P>(input: T) => Readonly<T>;
+/**
+ * This type helper is useful for forcing function generics to be explicitly provided, rather than
+ * inferring them from the given inputs. See the test file for examples.
+ */
+export declare type NoInfer<T> = [T][T extends any ? 0 : never];
+/**
+ * This is a type helper that ensures the given input matches the given generic type. The generic is
+ * setup in such a way that if it is omitted (which is typically allowed in TypeScript, resulting in
+ * the generic being inferred from the inputs), there will actually be a type error. This forces
+ * each usage of this function to explicitly specify the generic, thus giving us type safety for the
+ * input.
+ */
+export declare function ensureType<ExpectedType = never>(input: NoInfer<ExpectedType>): NoInfer<ExpectedType>;

package/dist/esm/augments/type.js

@@ -0,0 +1,24 @@
+/**
+ * This function returns another function that simply returns whatever input it's given. However, it
+ * also checks that the input matches the original wrapNarrowTypeWithTypeCheck's generic, while
+ * maintaining strict "const" like typing.
+ *
+ * Use like this: wrapNarrowTypeWithTypeCheck<EnforcedTypeHere>()(valueToEnforceTypeOn as const)
+ *
+ * Sometimes "as const" isn't required, usually it is for any object or array though.
+ */
+export function wrapNarrowTypeWithTypeCheck() {
+    return (input) => {
+        return input;
+    };
+}
+/**
+ * This is a type helper that ensures the given input matches the given generic type. The generic is
+ * setup in such a way that if it is omitted (which is typically allowed in TypeScript, resulting in
+ * the generic being inferred from the inputs), there will actually be a type error. This forces
+ * each usage of this function to explicitly specify the generic, thus giving us type safety for the
+ * input.
+ */
+export function ensureType(input) {
+    return input;
+}

package/dist/esm/index.d.ts

@@ -0,0 +1,15 @@
+export * from './augments/ansi';
+export * from './augments/array';
+export * from './augments/async';
+export * from './augments/common-number';
+export * from './augments/common-string';
+export * from './augments/date';
+export * from './augments/environment';
+export * from './augments/error';
+export * from './augments/function';
+export * from './augments/object';
+export * from './augments/promise';
+export * from './augments/regexp';
+export * from './augments/tuple';
+export * from './augments/type';
+export * from './augments/type-of';

package/dist/esm/index.js

@@ -0,0 +1,15 @@
+export * from './augments/ansi';
+export * from './augments/array';
+export * from './augments/async';
+export * from './augments/common-number';
+export * from './augments/common-string';
+export * from './augments/date';
+export * from './augments/environment';
+export * from './augments/error';
+export * from './augments/function';
+export * from './augments/object';
+export * from './augments/promise';
+export * from './augments/regexp';
+export * from './augments/tuple';
+export * from './augments/type';
+export * from './augments/type-of';

package/dist/types/augments/ansi.d.ts

@@ -0,0 +1 @@
+export declare const ansiRegex: RegExp;

package/dist/types/augments/array.d.ts

@@ -0,0 +1,13 @@
+import { AtLeastTuple } from './tuple';
+import { ArrayElement } from './type';
+export declare function filterOutIndexes<T>(array: ReadonlyArray<T>, indexes: ReadonlyArray<number>): T[];
+export declare function flatten2dArray<T>(array2d: ReadonlyArray<ReadonlyArray<T>>): T[];
+export declare type AtLeastOneEntryArray<ArrayGeneric extends ReadonlyArray<any>> = AtLeastTuple<ArrayElement<ArrayGeneric>, 1>;
+export declare function trimArrayStrings(input: ReadonlyArray<string>): string[];
+export declare function typedArrayIncludes<T>(array: ReadonlyArray<T>, input: unknown): input is T;
+declare type MapCallbackType<ArrayType extends ReadonlyArray<any>, OutputType> = (value: ArrayElement<ArrayType>, index: number, array: ArrayType) => OutputType;
+/** Preserves tuple types. */
+export declare function typedMap<InputArrayGeneric extends ReadonlyArray<any>, OutputType>(arrayToMap: InputArrayGeneric, mapCallback: MapCallbackType<InputArrayGeneric, OutputType>): {
+    [Index in keyof InputArrayGeneric]: OutputType;
+};
+export {};

package/dist/types/augments/async.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Acts like calling Array.prototype.forEach in that all elements are executed upon in order, and
+ * each execution is blocking. Meaning, the callback won't be called on element 2 until the callback
+ * has finished its call on element 1.
+ */
+export declare function awaitedForEach<OriginalGeneric>(input: ReadonlyArray<OriginalGeneric>, callback: (arrayElement: OriginalGeneric, index: number, wholeArray: ReadonlyArray<OriginalGeneric>) => void | PromiseLike<void>): Promise<void>;
+export declare function awaitedBlockingMap<OriginalGeneric, MappedGeneric>(input: ReadonlyArray<OriginalGeneric>, callback: (arrayElement: OriginalGeneric, index: number, wholeArray: ReadonlyArray<OriginalGeneric>) => MappedGeneric | PromiseLike<MappedGeneric>): Promise<Awaited<MappedGeneric>[]>;
+export declare function awaitedFilter<OriginalGeneric>(arrayInput: ReadonlyArray<OriginalGeneric>, filterCallback: (arrayElement: OriginalGeneric, index: number, wholeArray: ReadonlyArray<OriginalGeneric>) => Promise<unknown>, options?: {
+    /**
+     * Each call to the filter callback is blocking, meaning the next one won't start until the
+     * current one finishes. By default this is false.
+     */
+    blocking?: boolean | undefined;
+}): Promise<OriginalGeneric[]>;

package/dist/types/augments/common-number.d.ts

@@ -0,0 +1,32 @@
+export declare function addCommasToNumber(input: number): string;
+export declare function clamp(
+/**
+ * This uses a destructured object so that consumers cannot get confused as to which input is
+ * which (which would be easy to do since they're all of the same type).
+ */
+{ value, min, max, }: {
+    value: number;
+    min: number;
+    max: number;
+}): number;
+/**
+ * This truncates a number such that is will at a max have 6 characters including suffix, decimal
+ * point, or comma.
+ *
+ * Default suffixes are:
+ *
+ *     '', // no suffix, numbers below 1000
+ *     'k', // thousand
+ *     'M', // million
+ *     'B', // billion
+ *     'T', // trillion
+ *     'P', // peta-, quadrillion
+ *     'E', // exa- quintillion
+ *     'Z', // zetta- sextillion
+ *     'Y', // yotta- septillion
+ */
+export declare function truncateNumber(originalValue: unknown, { customSuffixes, suppressErrorLogging, customErrorLogCallback, }?: {
+    customSuffixes?: ReadonlyArray<string>;
+    suppressErrorLogging?: boolean;
+    customErrorLogCallback?: (...args: any) => void;
+}): string;

package/dist/types/augments/common-string.d.ts

@@ -0,0 +1,44 @@
+import { AtLeastTuple } from './tuple';
+/**
+ * Join elements into a string with commas separating each value. Add a conjunction before the final
+ * item in the list. If the array has a length < 2, the conjunction is not added. If the list is
+ * only of length 2, then no commas are added.
+ *
+ * @param list Array of items to be converted into strings. Works best if these are simply strings
+ *   to begin with.
+ * @param conjunction Defaults to 'and'. The conjunction to be used before the final element.
+ */
+export declare function joinWithFinalConjunction(list: ReadonlyArray<any>, conjunction?: string): string;
+export declare function removeAnsiEscapeCodes(input: string): string;
+export declare const removeColor: typeof removeAnsiEscapeCodes;
+export declare function removeCommasFromNumberString(numberString: string): string;
+/** Collapse all consecutive white space into just one space and trim surrounding whitespace. */
+export declare function collapseWhiteSpace(input: string): string;
+/** Same as String.prototype.split but includes the delimiter to split by in the output array. */
+export declare function splitIncludeSplit(original: string, splitterInput: string | RegExp, caseSensitive: boolean): readonly string[];
+export declare type CasingOptions = {
+    capitalizeFirstLetter: boolean;
+};
+export declare function capitalizeFirstLetter<InputGeneric extends string>(input: InputGeneric): Capitalize<InputGeneric>;
+export declare function kebabCaseToCamelCase(rawKebabCase: string, casingOptions?: Partial<CasingOptions> | undefined): string;
+export declare function camelCaseToKebabCase(rawCamelCase: string): string;
+export declare function replaceStringAtIndex(originalString: string, start: number, newString: string, length?: number): string;
+/**
+ * Escapes characters from the given string so that it can be used within a RegExp without being
+ * parsed as RegExp syntax.
+ */
+export declare function escapeStringForRegExp(input: string): string;
+export declare function getAllIndexesOf<IncludeLength extends boolean | undefined>({ searchIn, searchFor, caseSensitive, includeLength, }: {
+    searchIn: string;
+    searchFor: string | RegExp;
+    /**
+     * CaseSensitive only applies when the input is a string. Otherwise, the RegExp's "i" flag is
+     * used to determine case sensitivity.
+     */
+    caseSensitive: boolean;
+    includeLength?: IncludeLength;
+}): IncludeLength extends true ? {
+    index: number;
+    length: number;
+}[] : number[];
+export declare function typedSplit(input: string, splitString: string): AtLeastTuple<string, 1>;