@augment-vir/common 4.6.1 → 5.0.1

package/dist/esm/augments/common-number.js

@@ -0,0 +1,105 @@
+import { removeCommasFromNumberString, typedSplit } from './common-string';
+import { safeMatch } from './regexp';
+export function addCommasToNumber(input) {
+    const stringValue = String(input);
+    const [digits, decimalValues,] = stringValue.split('.');
+    const decimalString = decimalValues ? `.${decimalValues}` : '';
+    const separated = safeMatch(digits.split('').reverse().join(''), /.{1,3}/g)
+        .reverse()
+        .map((entry) => entry.split('').reverse().join(''));
+    const withCommas = separated.join(',');
+    return `${withCommas}${decimalString}`;
+}
+export 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, }) {
+    return Math.max(Math.min(value, max), min);
+}
+const defaultTruncationSuffixes = [
+    '',
+    'k',
+    'M',
+    'B',
+    'T',
+    'P',
+    'E',
+    'Z',
+    'Y', // yotta- septillion
+];
+function recursiveTruncation(value, recursionDepth = 0, decimalValues = '') {
+    var _a;
+    if (value.includes('e+')) {
+        throw new Error(`Number is too large, it cannot be truncated: ${value}`);
+    }
+    else if (value.includes('e-')) {
+        throw new Error(`Number is too small, it cannot be truncated: ${value}`);
+    }
+    const split = typedSplit(value, '.');
+    decimalValues = (_a = split[1]) !== null && _a !== void 0 ? _a : decimalValues;
+    const amount = split[0];
+    if (amount.length > 3) {
+        decimalValues = amount.slice(-3);
+        return recursiveTruncation(amount.slice(0, -3), recursionDepth + 1, decimalValues);
+    }
+    return {
+        value: amount,
+        decimalValues,
+        recursionDepth,
+    };
+}
+const maxDecimals = 4;
+/**
+ * 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 function truncateNumber(originalValue, { customSuffixes, suppressErrorLogging, customErrorLogCallback, } = {}) {
+    try {
+        const value = typeof originalValue === 'number'
+            ? originalValue
+            : typeof originalValue === 'string'
+                ? Number(removeCommasFromNumberString(originalValue))
+                : Number(originalValue);
+        if (isNaN(value)) {
+            throw new Error(`${originalValue} could not be converted into a number.`);
+        }
+        const stringValue = String(value);
+        const results = recursiveTruncation(stringValue);
+        const suffixes = customSuffixes !== null && customSuffixes !== void 0 ? customSuffixes : defaultTruncationSuffixes;
+        const suffix = suffixes[results.recursionDepth];
+        if (suffix === undefined) {
+            throw new Error(`Number is too large, could not truncate: ${value}`);
+        }
+        const decimalPlaces = maxDecimals - (results.value.length - 1) - suffix.length;
+        const decimalValues = results.decimalValues.replace(/0+$/, '').slice(0, decimalPlaces);
+        const withDecimal = decimalValues.length ? `.${decimalValues}` : '';
+        const combined = `${results.value}${withDecimal}${suffix}`;
+        if (combined.length > stringValue.length + 1) {
+            return addCommasToNumber(value);
+        }
+        else {
+            return combined;
+        }
+    }
+    catch (error) {
+        const errorCallback = customErrorLogCallback ? customErrorLogCallback : console.error;
+        if (!suppressErrorLogging) {
+            errorCallback(error);
+        }
+        return String(originalValue);
+    }
+}

package/dist/esm/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>;

package/dist/esm/augments/common-string.js

@@ -0,0 +1,180 @@
+import { ansiRegex } from './ansi';
+import { deDupeRegExFlags } from './regexp';
+/**
+ * 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 function joinWithFinalConjunction(list, conjunction = 'and') {
+    if (list.length < 2) {
+        /**
+         * If there are not multiple things in the list to join, just turn the list into a string
+         * for an empty list, this will be '', for a single item list, this will just be the first
+         * item as a string.
+         */
+        return list.join('');
+    }
+    /** When there are only two items in the list, we don't want any commas. */
+    const commaSep = list.length > 2 ? ', ' : ' ';
+    const commaJoined = list.slice(0, -1).join(commaSep);
+    const fullyJoined = `${commaJoined}${commaSep}${conjunction} ${list[list.length - 1]}`;
+    return fullyJoined;
+}
+export function removeAnsiEscapeCodes(input) {
+    return input.replace(ansiRegex, '');
+}
+export const removeColor = removeAnsiEscapeCodes;
+export function removeCommasFromNumberString(numberString) {
+    return numberString.replace(/,/g, '');
+}
+/** Collapse all consecutive white space into just one space and trim surrounding whitespace. */
+export function collapseWhiteSpace(input) {
+    return (input
+        // sometimes \n isn't included in \s
+        .replace(/\n/g, ' ')
+        .trim()
+        .replace(/\s{2,}/g, ' '));
+}
+/** Same as String.prototype.split but includes the delimiter to split by in the output array. */
+export function splitIncludeSplit(original, splitterInput, caseSensitive) {
+    const indexLengths = getAllIndexesOf({
+        searchIn: original,
+        searchFor: splitterInput,
+        caseSensitive,
+        includeLength: true,
+    });
+    const splitter = makeCaseInsensitiveRegExp(splitterInput, caseSensitive);
+    const splits = original.split(splitter);
+    const splitterIncluded = splits.reduce((accum, current, index) => {
+        // this will be undefined on the last index
+        const splitterLength = indexLengths[index];
+        const includeCurrent = accum.concat(current);
+        if (splitterLength) {
+            const splitterMatch = original.slice(splitterLength.index, splitterLength.index + splitterLength.length);
+            return includeCurrent.concat(splitterMatch);
+        }
+        else {
+            return includeCurrent;
+        }
+    }, []);
+    return splitterIncluded;
+}
+const defaultCasingOptions = {
+    capitalizeFirstLetter: false,
+};
+export function capitalizeFirstLetter(input) {
+    if (!input.length) {
+        return '';
+    }
+    const firstLetter = input[0];
+    return (firstLetter.toUpperCase() + input.slice(1));
+}
+function maybeCapitalize(input, casingOptions) {
+    return casingOptions.capitalizeFirstLetter ? capitalizeFirstLetter(input) : input;
+}
+export function kebabCaseToCamelCase(rawKebabCase, casingOptions = defaultCasingOptions) {
+    const kebabCase = rawKebabCase.toLowerCase();
+    if (!kebabCase.length) {
+        return '';
+    }
+    const camelCase = kebabCase
+        .replace(/^-+/, '')
+        .replace(/-{2,}/g, '-')
+        .replace(/-(?:.|$)/g, (dashMatch) => {
+        const letter = dashMatch[1];
+        if (letter) {
+            return letter.toUpperCase();
+        }
+        else {
+            return '';
+        }
+    });
+    return maybeCapitalize(camelCase, casingOptions);
+}
+function isLowerCase(input) {
+    // this excludes letters that are identical between lower and upper case like punctuation
+    return input !== input.toUpperCase();
+}
+export function camelCaseToKebabCase(rawCamelCase) {
+    const kebabCase = rawCamelCase
+        .split('')
+        .reduce((accum, currentLetter, index, originalString) => {
+        const previousLetter = index > 0 ? originalString[index - 1] : '';
+        const nextLetter = index < originalString.length - 1 ? originalString[index + 1] : '';
+        const possibleWordBoundary = isLowerCase(previousLetter) || isLowerCase(nextLetter);
+        if (currentLetter === currentLetter.toLowerCase() ||
+            index === 0 ||
+            !possibleWordBoundary) {
+            accum += currentLetter;
+        }
+        else {
+            accum += `-${currentLetter.toLowerCase()}`;
+        }
+        return accum;
+    }, '')
+        .toLowerCase();
+    return kebabCase;
+}
+export function replaceStringAtIndex(originalString, start, newString, length = newString.length) {
+    const before = originalString.substring(0, start);
+    const after = originalString.substring(start + length);
+    return `${before}${newString}${after}`;
+}
+/**
+ * Escapes characters from the given string so that it can be used within a RegExp without being
+ * parsed as RegExp syntax.
+ */
+export function escapeStringForRegExp(input) {
+    return input.replace(/[\^$\\.*+?()[\]{}|]/g, '\\$&');
+}
+function makeCaseInsensitiveRegExp(searchForInput, caseSensitive) {
+    const regExpFlags = `g${!caseSensitive && typeof searchForInput === 'string' ? 'i' : ''}`;
+    const searchFor = searchForInput instanceof RegExp
+        ? new RegExp(searchForInput.source, deDupeRegExFlags(`${searchForInput.flags}${regExpFlags}`))
+        : new RegExp(escapeStringForRegExp(searchForInput), regExpFlags);
+    return searchFor;
+}
+export function getAllIndexesOf({ searchIn, searchFor, caseSensitive, includeLength, }) {
+    const searchRegExp = makeCaseInsensitiveRegExp(searchFor, caseSensitive);
+    const indexes = [];
+    const indexesAndLengths = [];
+    searchIn.replace(searchRegExp, (...matchResults) => {
+        /**
+         * Grabbing the second to last entry in the array (rather than the second) takes capture
+         * groups into account.
+         */
+        const matchIndex = matchResults[matchResults.length - 2];
+        // this is used as a type safety catch and cannot actually be triggered on purpose
+        // istanbul ignore next
+        if (typeof matchIndex !== 'number') {
+            throw new Error(`Match index "${matchIndex}" is not a number. Searching for "${searchFor}" in "${searchIn}".`);
+        }
+        const regExpMatch = matchResults[0];
+        // this is used as a type safety catch and cannot actually be triggered on purpose
+        // istanbul ignore next
+        if (typeof regExpMatch !== 'string') {
+            throw new Error(`regExpMatch should've been a string but was ${typeof regExpMatch}!`);
+        }
+        indexesAndLengths.push({ index: matchIndex, length: regExpMatch.length });
+        indexes.push(matchIndex);
+        const originalMatch = matchResults[0];
+        // this is used as a type safety catch and cannot actually be triggered on purpose
+        // istanbul ignore next
+        if (typeof originalMatch !== 'string') {
+            throw new Error(`Original match when searching for "${searchFor}" in "${searchIn}" at index ${matchIndex} is not a string.`);
+        }
+        /**
+         * Don't actually change any text. What we do here doesn't matter because we're not
+         * using the output of the .replace method, we're just producing side effects.
+         */
+        return originalMatch;
+    });
+    return (includeLength ? indexesAndLengths : indexes);
+}
+export function typedSplit(input, splitString) {
+    return input.split(splitString);
+}

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

@@ -0,0 +1,26 @@
+export declare const englishFullMonthNames: readonly ["january", "february", "march", "april", "may", "june", "july", "august", "september", "october", "november", "december"];
+export declare const englishShortMonthNames: string[];
+export declare class InvalidDateError extends Error {
+    readonly name = "InvalidDateError";
+}
+/**
+ * @param slashFormatString String that should be of format "MM/DD/YY", "MM/DD/YYYY". When the year
+ *   portion only contains 2 numbers ("MM/DD/YY") the century must be provided in the form of the
+ *   yearPrefix input.
+ * @param yearPrefix String or number that is used to prefix slash format strings that only contain
+ *   2 digits ("MM/DD/YY"). If the year is entirely missing form the given slash format string, the
+ *   year will default to year 00 of the given century. See test file for examples.
+ */
+export declare function createDateFromSlashFormat(slashFormatString: string, yearPrefix?: number | string): Date;
+/**
+ * @param commaFormatString Should be at string of the form "monthName dayNumber, fullYear" Example:
+ *   "May 19, 2005"
+ * @param ignoreInvalidMonth Set to true to ignore invalid months and just use the current UTC month
+ */
+export declare function createDateFromNamedCommaFormat(commaFormatString: string, ignoreInvalidMonth?: boolean): Date;
+/**
+ * Converts an iso-formatted string to a UTC date object. The time is nulled out to all zeros.
+ *
+ * @param isoFormatString Should be a date in the format YYYY-MM-DD.
+ */
+export declare function createDateFromUtcIsoFormat(isoFormatString: string): Date;

package/dist/esm/augments/date.js

@@ -0,0 +1,74 @@
+export const englishFullMonthNames = [
+    'january',
+    'february',
+    'march',
+    'april',
+    'may',
+    'june',
+    'july',
+    'august',
+    'september',
+    'october',
+    'november',
+    'december',
+];
+export const englishShortMonthNames = englishFullMonthNames.map((longMonthName) => longMonthName.slice(0, 3));
+export class InvalidDateError extends Error {
+    constructor() {
+        super(...arguments);
+        this.name = 'InvalidDateError';
+    }
+}
+/**
+ * @param slashFormatString String that should be of format "MM/DD/YY", "MM/DD/YYYY". When the year
+ *   portion only contains 2 numbers ("MM/DD/YY") the century must be provided in the form of the
+ *   yearPrefix input.
+ * @param yearPrefix String or number that is used to prefix slash format strings that only contain
+ *   2 digits ("MM/DD/YY"). If the year is entirely missing form the given slash format string, the
+ *   year will default to year 00 of the given century. See test file for examples.
+ */
+export function createDateFromSlashFormat(slashFormatString, yearPrefix = '') {
+    const [month, day, rawYearEnding = '',] = slashFormatString.split('/');
+    if (!month || !day) {
+        throw new Error(`Unable to extract month or day from "${slashFormatString}"`);
+    }
+    const yearEnding = rawYearEnding.length < 4 ? `${yearPrefix}${rawYearEnding.padStart(2, '0')}` : rawYearEnding;
+    const returnDate = createDateFromUtcIsoFormat(`${yearEnding.padStart(4, '0')}-${month.padStart(2, '0')}-${day.padStart(2, '0')}`);
+    return returnDate;
+}
+/**
+ * @param commaFormatString Should be at string of the form "monthName dayNumber, fullYear" Example:
+ *   "May 19, 2005"
+ * @param ignoreInvalidMonth Set to true to ignore invalid months and just use the current UTC month
+ */
+export function createDateFromNamedCommaFormat(commaFormatString, ignoreInvalidMonth = false) {
+    const [monthName, dayNumber, fullYear,] = commaFormatString.replace(',', '').split(' ');
+    if (!monthName || !dayNumber || !fullYear) {
+        throw new InvalidDateError(`Invalid ${createDateFromNamedCommaFormat.name} input: ${commaFormatString}`);
+    }
+    const longMonthIndex = englishFullMonthNames.indexOf(monthName.toLowerCase());
+    const shortMonthIndex = englishShortMonthNames.indexOf(monthName.toLowerCase());
+    let monthIndex = longMonthIndex === -1 ? shortMonthIndex : longMonthIndex;
+    if (monthIndex === -1) {
+        if (ignoreInvalidMonth) {
+            monthIndex = new Date().getUTCMonth();
+        }
+        else {
+            throw new InvalidDateError(`Month name ${monthName} was not found.`);
+        }
+    }
+    const returnDate = createDateFromUtcIsoFormat(`${fullYear.padStart(4, '0')}-${String(monthIndex + 1).padStart(2, '0')}-${dayNumber.padStart(2, '0')}`);
+    return returnDate;
+}
+/**
+ * Converts an iso-formatted string to a UTC date object. The time is nulled out to all zeros.
+ *
+ * @param isoFormatString Should be a date in the format YYYY-MM-DD.
+ */
+export function createDateFromUtcIsoFormat(isoFormatString) {
+    const utcDate = new Date(isoFormatString + 'T00:00:00.000Z');
+    if (isNaN(Number(utcDate))) {
+        throw new InvalidDateError(`Invalid utc date formed from input "${isoFormatString}"`);
+    }
+    return utcDate;
+}

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

@@ -0,0 +1 @@
+export declare function isBrowser(): boolean;

package/dist/esm/augments/environment.js

@@ -0,0 +1,3 @@
+export function isBrowser() {
+    return typeof window !== 'undefined';
+}

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

@@ -0,0 +1,8 @@
+import { AtLeastTuple } from './tuple';
+export declare function combineErrors(errors: AtLeastTuple<Error, 1>): Error;
+export declare function combineErrors(errors: ReadonlyArray<never>): undefined;
+export declare function combineErrors(errors: ReadonlyArray<Error>): Error | undefined;
+export declare function combineErrors(errors?: undefined): undefined;
+export declare function combineErrorMessages(errors?: ReadonlyArray<Error | string | undefined> | undefined): string;
+export declare function extractErrorMessage(error: unknown): string;
+export declare function ensureError(input: unknown): Error;

package/dist/esm/augments/error.js

@@ -0,0 +1,36 @@
+import { isTruthy } from './function';
+export function combineErrors(errors) {
+    if (!errors || errors.length === 0) {
+        return undefined;
+    }
+    const firstError = errors[0];
+    if (errors.length === 1 && firstError) {
+        return firstError;
+    }
+    return new Error(errors.map((error) => extractErrorMessage(error).trim()).join('\n'));
+}
+export function combineErrorMessages(errors) {
+    if (!errors) {
+        return '';
+    }
+    return errors.map(extractErrorMessage).filter(isTruthy).join('\n');
+}
+export function extractErrorMessage(error) {
+    if (!error) {
+        return '';
+    }
+    if (error instanceof Error) {
+        return error.message;
+    }
+    else {
+        return String(error);
+    }
+}
+export function ensureError(input) {
+    if (input instanceof Error) {
+        return input;
+    }
+    else {
+        return new Error(extractErrorMessage(input));
+    }
+}

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

@@ -0,0 +1 @@
+export declare function isTruthy<T>(input: T): input is NonNullable<T>;

package/dist/esm/augments/function.js

@@ -0,0 +1,3 @@
+export function isTruthy(input) {
+    return !!input;
+}

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

@@ -0,0 +1,63 @@
+import { AtLeastOneEntryArray } from './array';
+import { NoInfer, RequiredBy, UnPromise } from './type';
+export declare function getEnumTypedKeys<T extends object>(input: T): (keyof T)[];
+export declare function getEnumTypedValues<T extends object>(input: T): T[keyof T][];
+export declare function isEnumValue<T extends object>(input: unknown, checkEnum: T): input is T[keyof T];
+export declare function isKeyof<ObjectGeneric>(key: PropertyKey, object: ObjectGeneric): key is keyof object;
+export declare function filterToEnumValues<T extends object>(inputs: ReadonlyArray<unknown>, checkEnum: T, caseInsensitive?: boolean): T[keyof T][];
+export declare function getObjectTypedKeys<ObjectGeneric extends unknown>(input: ObjectGeneric): ReadonlyArray<keyof ObjectGeneric>;
+export declare function getObjectTypedValues<ObjectGeneric extends unknown>(input: ObjectGeneric): ObjectGeneric[keyof ObjectGeneric][];
+declare type ExtractValue<KeyGeneric extends PropertyKey, ParentGeneric> = KeyGeneric extends keyof ParentGeneric ? RequiredBy<ParentGeneric, KeyGeneric>[KeyGeneric] : KeyGeneric extends keyof Extract<ParentGeneric, Record<KeyGeneric, any>> ? RequiredBy<Extract<ParentGeneric, Record<KeyGeneric, any>>, KeyGeneric>[KeyGeneric] : never;
+declare type CombinedParentValue<KeyGeneric extends PropertyKey, ParentGeneric> = ExtractValue<KeyGeneric, ParentGeneric> extends never ? unknown : ExtractValue<KeyGeneric, ParentGeneric>;
+declare type CombineTypeWithKey<KeyGeneric extends PropertyKey, ParentGeneric> = ParentGeneric & Record<KeyGeneric, CombinedParentValue<KeyGeneric, ParentGeneric>>;
+export declare function typedHasProperty<KeyGeneric extends PropertyKey, ParentGeneric>(inputObject: ParentGeneric, inputKey: KeyGeneric): inputObject is CombineTypeWithKey<KeyGeneric, ParentGeneric>;
+export declare function typedHasProperties<KeyGeneric extends PropertyKey, ParentGeneric>(inputObject: ParentGeneric, inputKeys: ReadonlyArray<KeyGeneric>): inputObject is CombineTypeWithKey<KeyGeneric, ParentGeneric>;
+export declare function isObject(input: any): input is NonNullable<object>;
+export declare function getEntriesSortedByKey(input: object): [string, unknown][];
+export declare function areJsonEqual(a: object, b: object): boolean;
+export declare type InnerMappedValues<EntireInputGeneric extends object, MappedValueGeneric> = {
+    [MappedProp in keyof EntireInputGeneric]: MappedValueGeneric;
+};
+export declare type MappedValues<EntireInputGeneric extends object, MappedValueGeneric> = MappedValueGeneric extends PromiseLike<unknown> ? Promise<InnerMappedValues<EntireInputGeneric, UnPromise<MappedValueGeneric>>> : InnerMappedValues<EntireInputGeneric, UnPromise<MappedValueGeneric>>;
+/**
+ * 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 declare function mapObjectValues<EntireInputGeneric extends object, MappedValueGeneric>(inputObject: EntireInputGeneric, mapCallback: (inputKey: keyof EntireInputGeneric, keyValue: EntireInputGeneric[typeof inputKey], fullObject: EntireInputGeneric) => MappedValueGeneric): MappedValues<EntireInputGeneric, MappedValueGeneric>;
+export declare function filterObject<ObjectGeneric extends object>(inputObject: ObjectGeneric, callback: (key: keyof ObjectGeneric, value: ObjectValueType<ObjectGeneric>, fullObject: ObjectGeneric) => boolean): Partial<ObjectGeneric>;
+/** The input here must be serializable otherwise JSON parsing errors will be thrown */
+export declare function copyThroughJson<T>(input: T): T;
+export declare type ObjectValueType<T extends object> = T[keyof T];
+/**
+ * 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 declare function matchesObjectShape<MatchThisGeneric extends object>(testThisOne: unknown, compareToThisOne: NoInfer<ObjectWithAtLeastSingleEntryArrays<MatchThisGeneric>>, allowExtraProps?: boolean, shouldLogWhy?: boolean): testThisOne is MatchThisGeneric;
+export declare type ObjectWithAtLeastSingleEntryArrays<BaseObject extends object> = {
+    [Prop in keyof BaseObject]: BaseObject[Prop] extends ReadonlyArray<any> ? AtLeastOneEntryArray<BaseObject[Prop]> : BaseObject[Prop] extends object ? ObjectWithAtLeastSingleEntryArrays<BaseObject[Prop]> : BaseObject[Prop];
+};
+/**
+ * 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 declare function assertMatchesObjectShape<MatchThisGeneric extends object = never>(testThisOne: unknown, compareToThisOne: NoInfer<ObjectWithAtLeastSingleEntryArrays<MatchThisGeneric>>, allowExtraProps?: boolean): asserts testThisOne is MatchThisGeneric;
+export declare function typedObjectFromEntries<KeyType extends PropertyKey, ValueType>(entries: ReadonlyArray<Readonly<[KeyType, ValueType]>>): Record<KeyType, ValueType>;
+export {};