@augment-vir/common 11.0.0 → 11.1.1

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

@@ -13,6 +13,7 @@ export type DeferredPromiseWrapper<T> = {
     promise: Promise<T>;
     resolve: (value: T | PromiseLike<T>) => void;
     reject: (reason?: any) => void;
+    isSettled: () => boolean;
 };
 export declare function createDeferredPromiseWrapper<T = void>(): DeferredPromiseWrapper<T>;
 export type WaitForConditionInputs = {

package/dist/cjs/augments/promise.js

@@ -58,9 +58,16 @@ exports.wrapPromiseInTimeout = wrapPromiseInTimeout;
 function createDeferredPromiseWrapper() {
     let resolve;
     let reject;
+    let settled = false;
     const promise = new Promise((resolveCallback, rejectCallback) => {
-        resolve = resolveCallback;
-        reject = rejectCallback;
+        resolve = (value) => {
+            settled = true;
+            return resolveCallback(value);
+        };
+        reject = (reason) => {
+            settled = true;
+            rejectCallback(reason);
+        };
     });
     // no way to test this edge case
     // istanbul ignore next
@@ -71,6 +78,9 @@ function createDeferredPromiseWrapper() {
         promise,
         resolve,
         reject,
+        isSettled() {
+            return settled;
+        },
     };
 }
 exports.createDeferredPromiseWrapper = createDeferredPromiseWrapper;

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

@@ -13,6 +13,7 @@ export type DeferredPromiseWrapper<T> = {
     promise: Promise<T>;
     resolve: (value: T | PromiseLike<T>) => void;
     reject: (reason?: any) => void;
+    isSettled: () => boolean;
 };
 export declare function createDeferredPromiseWrapper<T = void>(): DeferredPromiseWrapper<T>;
 export type WaitForConditionInputs = {

package/dist/esm/augments/promise.js

@@ -50,9 +50,16 @@ export function wrapPromiseInTimeout(durationMs, originalPromise) {
 export function createDeferredPromiseWrapper() {
     let resolve;
     let reject;
+    let settled = false;
     const promise = new Promise((resolveCallback, rejectCallback) => {
-        resolve = resolveCallback;
-        reject = rejectCallback;
+        resolve = (value) => {
+            settled = true;
+            return resolveCallback(value);
+        };
+        reject = (reason) => {
+            settled = true;
+            rejectCallback(reason);
+        };
     });
     // no way to test this edge case
     // istanbul ignore next
@@ -63,6 +70,9 @@ export function createDeferredPromiseWrapper() {
         promise,
         resolve,
         reject,
+        isSettled() {
+            return settled;
+        },
     };
 }
 export async function waitForCondition({ conditionCallback, timeoutMs = 10000, intervalMs = 100, timeoutMessage = '', }) {

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

@@ -13,6 +13,7 @@ export type DeferredPromiseWrapper<T> = {
     promise: Promise<T>;
     resolve: (value: T | PromiseLike<T>) => void;
     reject: (reason?: any) => void;
+    isSettled: () => boolean;
 };
 export declare function createDeferredPromiseWrapper<T = void>(): DeferredPromiseWrapper<T>;
 export type WaitForConditionInputs = {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@augment-vir/common",
-    "version": "11.0.0",
+    "version": "11.1.1",
     "homepage": "https://github.com/electrovir/augment-vir/tree/main/packages/common",
     "bugs": {
         "url": "https://github.com/electrovir/augment-vir/issues"

package/dist/cjs/augments/nested-keys.d.ts

@@ -1,12 +0,0 @@
-import { UnionToIntersection } from 'type-fest';
-import { ObjectValueType } from '../object';
-export type NestedSequentialKeys<ObjectGeneric extends object> = ObjectValueType<{
-    [Prop in keyof ObjectGeneric]: NonNullable<ObjectGeneric[Prop]> extends object ? [Prop, ...(NestedSequentialKeys<NonNullable<ObjectGeneric[Prop]>> | [])] : [Prop];
-}>;
-export type NestedKeys<ObjectGeneric extends object> = UnionToIntersection<Extract<ObjectValueType<ObjectGeneric>, object>> extends object ? [
-    keyof ObjectGeneric,
-    ...(NestedKeys<UnionToIntersection<Extract<ObjectValueType<ObjectGeneric>, object>>> | [])
-] : [keyof ObjectGeneric];
-export type NestedValue<ObjectGeneric extends object, NestedKeysGeneric extends NestedSequentialKeys<ObjectGeneric>> = NestedKeysGeneric extends readonly [infer FirstEntry, ...infer FollowingEntries] ? FirstEntry extends keyof ObjectGeneric ? FollowingEntries extends never[] ? ObjectGeneric[FirstEntry] : ObjectGeneric[FirstEntry] extends object ? FollowingEntries extends NestedSequentialKeys<ObjectGeneric[FirstEntry]> ? NestedValue<ObjectGeneric[FirstEntry], FollowingEntries> : never : never : never : never;
-export declare function getValueFromNestedKeys<ObjectGeneric extends object, KeysGeneric extends NestedSequentialKeys<ObjectGeneric>>(inputObject: ObjectGeneric, nestedKeys: KeysGeneric): NestedValue<ObjectGeneric, KeysGeneric> | undefined;
-//# sourceMappingURL=nested-keys.d.ts.map

package/dist/cjs/augments/nested-keys.js

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getValueFromNestedKeys = void 0;
-const object_1 = require("./object");
-function getValueFromNestedKeys(inputObject, nestedKeys) {
-    /**
-     * Lots of as any casts in here because these types are, under the hood, pretty complex. Since
-     * the inputs and outputs of this function are well typed, these internal as any casts do not
-     * affect the external API of this function.
-     */
-    const keyToAccess = nestedKeys[0];
-    if (!(0, object_1.typedHasProperty)(inputObject, keyToAccess)) {
-        return undefined;
-    }
-    const currentValue = inputObject[keyToAccess];
-    if (nestedKeys.length > 1) {
-        return getValueFromNestedKeys(currentValue, nestedKeys.slice(1));
-    }
-    else {
-        return currentValue;
-    }
-}
-exports.getValueFromNestedKeys = getValueFromNestedKeys;

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

@@ -1,70 +0,0 @@
-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 type PartialWithNullable<T extends object> = {
-    [Prop in keyof T]?: T[Prop] | null | undefined;
-};
-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): Array<keyof ObjectGeneric>;
-export declare function getObjectTypedValues<ObjectGeneric extends unknown>(input: ObjectGeneric): ObjectGeneric[keyof ObjectGeneric][];
-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;
-type CombinedParentValue<KeyGeneric extends PropertyKey, ParentGeneric> = ExtractValue<KeyGeneric, ParentGeneric> extends never ? unknown : ExtractValue<KeyGeneric, ParentGeneric>;
-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 type InnerMappedValues<EntireInputGeneric extends object, MappedValueGeneric> = {
-    [MappedProp in keyof EntireInputGeneric]: MappedValueGeneric;
-};
-export 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 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 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];
-};
-export type NestedBoolean<MatchObject extends object> = Partial<{
-    [Prop in keyof MatchObject]: MatchObject[Prop] extends object ? NestedBoolean<MatchObject[Prop]> | boolean : boolean;
-}>;
-/**
- * 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, noCheckInnerValueOfTheseKeys?: NestedBoolean<typeof compareToThisOne>): asserts testThisOne is MatchThisGeneric;
-export declare function typedObjectFromEntries<KeyType extends PropertyKey, ValueType>(entries: ReadonlyArray<Readonly<[KeyType, ValueType]>>): Record<KeyType, ValueType>;
-export {};
-//# sourceMappingURL=object.d.ts.map

package/dist/cjs/augments/object.js

@@ -1,276 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.typedObjectFromEntries = exports.assertMatchesObjectShape = exports.matchesObjectShape = exports.copyThroughJson = exports.filterObject = exports.mapObjectValues = exports.areJsonEqual = exports.getEntriesSortedByKey = exports.isObject = exports.typedHasProperties = exports.typedHasProperty = exports.getObjectTypedValues = exports.getObjectTypedKeys = exports.filterToEnumValues = exports.isKeyof = exports.isEnumValue = exports.getEnumTypedValues = exports.getEnumTypedKeys = void 0;
-const error_1 = require("./error");
-const function_1 = require("./function");
-function getEnumTypedKeys(input) {
-    // enum keys are always strings
-    return getObjectTypedKeys(input).filter((key) => isNaN(Number(key)));
-}
-exports.getEnumTypedKeys = getEnumTypedKeys;
-function getEnumTypedValues(input) {
-    const keys = getEnumTypedKeys(input);
-    return keys.map((key) => input[key]);
-}
-exports.getEnumTypedValues = getEnumTypedValues;
-function isEnumValue(input, checkEnum) {
-    return getEnumTypedValues(checkEnum).includes(input);
-}
-exports.isEnumValue = isEnumValue;
-function isKeyof(key, object) {
-    return typedHasProperty(object, key);
-}
-exports.isKeyof = isKeyof;
-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));
-    }
-}
-exports.filterToEnumValues = filterToEnumValues;
-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),
-    ]);
-}
-exports.getObjectTypedKeys = getObjectTypedKeys;
-function getObjectTypedValues(input) {
-    return getObjectTypedKeys(input).map((key) => input[key]);
-}
-exports.getObjectTypedValues = getObjectTypedValues;
-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;
-    },
-];
-function typedHasProperty(inputObject, inputKey) {
-    if (!inputObject) {
-        return false;
-    }
-    return hasPropertyAttempts.some((attemptCallback) => {
-        try {
-            return attemptCallback(inputObject, inputKey);
-        }
-        catch (error) {
-            return false;
-        }
-    });
-}
-exports.typedHasProperty = typedHasProperty;
-function typedHasProperties(inputObject, inputKeys) {
-    return inputObject && inputKeys.every((key) => typedHasProperty(inputObject, key));
-}
-exports.typedHasProperties = typedHasProperties;
-function isObject(input) {
-    return !!input && typeof input === 'object';
-}
-exports.isObject = isObject;
-function getEntriesSortedByKey(input) {
-    return Object.entries(input).sort((tupleA, tupleB) => tupleA[0].localeCompare(tupleB[0]));
-}
-exports.getEntriesSortedByKey = getEntriesSortedByKey;
-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;
-    }
-}
-exports.areJsonEqual = areJsonEqual;
-/**
- * Creates a new object with the same properties as the input object, but with values set to the
- * result of mapCallback for each property.
- */
-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;
-    }
-}
-exports.mapObjectValues = mapObjectValues;
-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;
-    }, {});
-}
-exports.filterObject = filterObject;
-/** The input here must be serializable otherwise JSON parsing errors will be thrown */
-function copyThroughJson(input) {
-    try {
-        return JSON.parse(JSON.stringify(input));
-    }
-    catch (error) {
-        console.error(`Failed to JSON copy for`, input);
-        throw error;
-    }
-}
-exports.copyThroughJson = copyThroughJson;
-/**
- * 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.
- */
-function matchesObjectShape(testThisOne, compareToThisOne, allowExtraProps = false, shouldLogWhy = false) {
-    try {
-        assertMatchesObjectShape(testThisOne, compareToThisOne, allowExtraProps);
-        return true;
-    }
-    catch (error) {
-        if (shouldLogWhy) {
-            console.error(error);
-        }
-        return false;
-    }
-}
-exports.matchesObjectShape = matchesObjectShape;
-/**
- * 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.
- */
-function assertMatchesObjectShape(testThisOne, compareToThisOne, allowExtraProps = false, noCheckInnerValueOfTheseKeys = {}) {
-    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) => {
-        var _a;
-        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];
-        if (!noCheckInnerValueOfTheseKeys[key]) {
-            compareInnerValue(testValue, shouldMatch, throwKeyError, allowExtraProps, (_a = noCheckInnerValueOfTheseKeys[key]) !== null && _a !== void 0 ? _a : {});
-        }
-    });
-}
-exports.assertMatchesObjectShape = assertMatchesObjectShape;
-function compareInnerValue(testValue, matchValue, throwKeyError, allowExtraProps, noCheckInnerValueOfTheseKeys) {
-    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, allowExtraProps, noCheckInnerValueOfTheseKeys);
-                    return undefined;
-                }
-                catch (error) {
-                    return new Error(`entry at index "${index}" did not match expected shape: ${(0, error_1.extractErrorMessage)(error)}`);
-                }
-            })
-                .filter(function_1.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, allowExtraProps, noCheckInnerValueOfTheseKeys);
-    }
-}
-function typedObjectFromEntries(entries) {
-    return Object.fromEntries(entries);
-}
-exports.typedObjectFromEntries = typedObjectFromEntries;

package/dist/cjs/augments/pick-deep.d.ts

@@ -1,8 +0,0 @@
-import { UnionToIntersection } from 'type-fest';
-import { NestedKeys } from './object/nested-keys';
-type InnerPickDeep<OriginalObjectGeneric extends object, DeepKeys extends any[]> = UnionToIntersection<DeepKeys extends [infer CurrentLevelPick, ...infer RemainingKeys] ? {
-    [CurrentProp in Extract<CurrentLevelPick, keyof OriginalObjectGeneric>]: OriginalObjectGeneric[CurrentProp] extends object ? InnerPickDeep<OriginalObjectGeneric[CurrentProp], RemainingKeys> : OriginalObjectGeneric[CurrentProp];
-} : DeepKeys extends [infer CurrentLevelPick] ? CurrentLevelPick extends keyof OriginalObjectGeneric ? Pick<OriginalObjectGeneric, CurrentLevelPick> : never : never>;
-export type PickDeep<OriginalObjectGeneric extends object, DeepKeys extends NestedKeys<OriginalObjectGeneric>> = InnerPickDeep<OriginalObjectGeneric, DeepKeys>;
-export {};
-//# sourceMappingURL=pick-deep.d.ts.map

package/dist/cjs/augments/pick-deep.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -1,19 +0,0 @@
-import { AnyFunction } from './function';
-declare function getTypeOf(x: any): "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
-export type TypeOf = ReturnType<typeof getTypeOf>;
-export type TypeOfWithArray = TypeOf | 'array';
-export type TypeOfMapping = {
-    array: any[];
-    bigint: bigint;
-    boolean: boolean;
-    function: AnyFunction;
-    number: number;
-    object: Record<PropertyKey, unknown>;
-    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 {};
-//# sourceMappingURL=type-of.d.ts.map

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

@@ -1,17 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isTypeOfWithArray = exports.typeOfWithArray = void 0;
-// this function is not used at run time, it's only here for types
-// istanbul ignore next
-function getTypeOf(x) {
-    return typeof x;
-}
-function typeOfWithArray(input) {
-    return Array.isArray(input) ? 'array' : typeof input;
-}
-exports.typeOfWithArray = typeOfWithArray;
-function isTypeOfWithArray(input, testType) {
-    const inputType = typeOfWithArray(input);
-    return inputType === testType;
-}
-exports.isTypeOfWithArray = isTypeOfWithArray;

package/dist/esm/augments/nested-keys.d.ts

@@ -1,12 +0,0 @@
-import { UnionToIntersection } from 'type-fest';
-import { ObjectValueType } from '../object';
-export type NestedSequentialKeys<ObjectGeneric extends object> = ObjectValueType<{
-    [Prop in keyof ObjectGeneric]: NonNullable<ObjectGeneric[Prop]> extends object ? [Prop, ...(NestedSequentialKeys<NonNullable<ObjectGeneric[Prop]>> | [])] : [Prop];
-}>;
-export type NestedKeys<ObjectGeneric extends object> = UnionToIntersection<Extract<ObjectValueType<ObjectGeneric>, object>> extends object ? [
-    keyof ObjectGeneric,
-    ...(NestedKeys<UnionToIntersection<Extract<ObjectValueType<ObjectGeneric>, object>>> | [])
-] : [keyof ObjectGeneric];
-export type NestedValue<ObjectGeneric extends object, NestedKeysGeneric extends NestedSequentialKeys<ObjectGeneric>> = NestedKeysGeneric extends readonly [infer FirstEntry, ...infer FollowingEntries] ? FirstEntry extends keyof ObjectGeneric ? FollowingEntries extends never[] ? ObjectGeneric[FirstEntry] : ObjectGeneric[FirstEntry] extends object ? FollowingEntries extends NestedSequentialKeys<ObjectGeneric[FirstEntry]> ? NestedValue<ObjectGeneric[FirstEntry], FollowingEntries> : never : never : never : never;
-export declare function getValueFromNestedKeys<ObjectGeneric extends object, KeysGeneric extends NestedSequentialKeys<ObjectGeneric>>(inputObject: ObjectGeneric, nestedKeys: KeysGeneric): NestedValue<ObjectGeneric, KeysGeneric> | undefined;
-//# sourceMappingURL=nested-keys.d.ts.map

package/dist/esm/augments/nested-keys.js

@@ -1,19 +0,0 @@
-import { typedHasProperty } from './object';
-export function getValueFromNestedKeys(inputObject, nestedKeys) {
-    /**
-     * Lots of as any casts in here because these types are, under the hood, pretty complex. Since
-     * the inputs and outputs of this function are well typed, these internal as any casts do not
-     * affect the external API of this function.
-     */
-    const keyToAccess = nestedKeys[0];
-    if (!typedHasProperty(inputObject, keyToAccess)) {
-        return undefined;
-    }
-    const currentValue = inputObject[keyToAccess];
-    if (nestedKeys.length > 1) {
-        return getValueFromNestedKeys(currentValue, nestedKeys.slice(1));
-    }
-    else {
-        return currentValue;
-    }
-}

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

@@ -1,70 +0,0 @@
-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 type PartialWithNullable<T extends object> = {
-    [Prop in keyof T]?: T[Prop] | null | undefined;
-};
-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): Array<keyof ObjectGeneric>;
-export declare function getObjectTypedValues<ObjectGeneric extends unknown>(input: ObjectGeneric): ObjectGeneric[keyof ObjectGeneric][];
-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;
-type CombinedParentValue<KeyGeneric extends PropertyKey, ParentGeneric> = ExtractValue<KeyGeneric, ParentGeneric> extends never ? unknown : ExtractValue<KeyGeneric, ParentGeneric>;
-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 type InnerMappedValues<EntireInputGeneric extends object, MappedValueGeneric> = {
-    [MappedProp in keyof EntireInputGeneric]: MappedValueGeneric;
-};
-export 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 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 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];
-};
-export type NestedBoolean<MatchObject extends object> = Partial<{
-    [Prop in keyof MatchObject]: MatchObject[Prop] extends object ? NestedBoolean<MatchObject[Prop]> | boolean : boolean;
-}>;
-/**
- * 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, noCheckInnerValueOfTheseKeys?: NestedBoolean<typeof compareToThisOne>): asserts testThisOne is MatchThisGeneric;
-export declare function typedObjectFromEntries<KeyType extends PropertyKey, ValueType>(entries: ReadonlyArray<Readonly<[KeyType, ValueType]>>): Record<KeyType, ValueType>;
-export {};
-//# sourceMappingURL=object.d.ts.map

package/dist/esm/augments/object.js

@@ -1,255 +0,0 @@
-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, noCheckInnerValueOfTheseKeys = {}) {
-    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) => {
-        var _a;
-        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];
-        if (!noCheckInnerValueOfTheseKeys[key]) {
-            compareInnerValue(testValue, shouldMatch, throwKeyError, allowExtraProps, (_a = noCheckInnerValueOfTheseKeys[key]) !== null && _a !== void 0 ? _a : {});
-        }
-    });
-}
-function compareInnerValue(testValue, matchValue, throwKeyError, allowExtraProps, noCheckInnerValueOfTheseKeys) {
-    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, allowExtraProps, noCheckInnerValueOfTheseKeys);
-                    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, allowExtraProps, noCheckInnerValueOfTheseKeys);
-    }
-}
-export function typedObjectFromEntries(entries) {
-    return Object.fromEntries(entries);
-}

package/dist/esm/augments/pick-deep.d.ts

@@ -1,8 +0,0 @@
-import { UnionToIntersection } from 'type-fest';
-import { NestedKeys } from './object/nested-keys';
-type InnerPickDeep<OriginalObjectGeneric extends object, DeepKeys extends any[]> = UnionToIntersection<DeepKeys extends [infer CurrentLevelPick, ...infer RemainingKeys] ? {
-    [CurrentProp in Extract<CurrentLevelPick, keyof OriginalObjectGeneric>]: OriginalObjectGeneric[CurrentProp] extends object ? InnerPickDeep<OriginalObjectGeneric[CurrentProp], RemainingKeys> : OriginalObjectGeneric[CurrentProp];
-} : DeepKeys extends [infer CurrentLevelPick] ? CurrentLevelPick extends keyof OriginalObjectGeneric ? Pick<OriginalObjectGeneric, CurrentLevelPick> : never : never>;
-export type PickDeep<OriginalObjectGeneric extends object, DeepKeys extends NestedKeys<OriginalObjectGeneric>> = InnerPickDeep<OriginalObjectGeneric, DeepKeys>;
-export {};
-//# sourceMappingURL=pick-deep.d.ts.map

package/dist/esm/augments/pick-deep.js

@@ -1 +0,0 @@
-export {};

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

@@ -1,19 +0,0 @@
-import { AnyFunction } from './function';
-declare function getTypeOf(x: any): "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
-export type TypeOf = ReturnType<typeof getTypeOf>;
-export type TypeOfWithArray = TypeOf | 'array';
-export type TypeOfMapping = {
-    array: any[];
-    bigint: bigint;
-    boolean: boolean;
-    function: AnyFunction;
-    number: number;
-    object: Record<PropertyKey, unknown>;
-    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 {};
-//# sourceMappingURL=type-of.d.ts.map

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

@@ -1,12 +0,0 @@
-// 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/types/augments/nested-keys.d.ts

@@ -1,12 +0,0 @@
-import { UnionToIntersection } from 'type-fest';
-import { ObjectValueType } from '../object';
-export type NestedSequentialKeys<ObjectGeneric extends object> = ObjectValueType<{
-    [Prop in keyof ObjectGeneric]: NonNullable<ObjectGeneric[Prop]> extends object ? [Prop, ...(NestedSequentialKeys<NonNullable<ObjectGeneric[Prop]>> | [])] : [Prop];
-}>;
-export type NestedKeys<ObjectGeneric extends object> = UnionToIntersection<Extract<ObjectValueType<ObjectGeneric>, object>> extends object ? [
-    keyof ObjectGeneric,
-    ...(NestedKeys<UnionToIntersection<Extract<ObjectValueType<ObjectGeneric>, object>>> | [])
-] : [keyof ObjectGeneric];
-export type NestedValue<ObjectGeneric extends object, NestedKeysGeneric extends NestedSequentialKeys<ObjectGeneric>> = NestedKeysGeneric extends readonly [infer FirstEntry, ...infer FollowingEntries] ? FirstEntry extends keyof ObjectGeneric ? FollowingEntries extends never[] ? ObjectGeneric[FirstEntry] : ObjectGeneric[FirstEntry] extends object ? FollowingEntries extends NestedSequentialKeys<ObjectGeneric[FirstEntry]> ? NestedValue<ObjectGeneric[FirstEntry], FollowingEntries> : never : never : never : never;
-export declare function getValueFromNestedKeys<ObjectGeneric extends object, KeysGeneric extends NestedSequentialKeys<ObjectGeneric>>(inputObject: ObjectGeneric, nestedKeys: KeysGeneric): NestedValue<ObjectGeneric, KeysGeneric> | undefined;
-//# sourceMappingURL=nested-keys.d.ts.map

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

@@ -1,70 +0,0 @@
-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 type PartialWithNullable<T extends object> = {
-    [Prop in keyof T]?: T[Prop] | null | undefined;
-};
-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): Array<keyof ObjectGeneric>;
-export declare function getObjectTypedValues<ObjectGeneric extends unknown>(input: ObjectGeneric): ObjectGeneric[keyof ObjectGeneric][];
-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;
-type CombinedParentValue<KeyGeneric extends PropertyKey, ParentGeneric> = ExtractValue<KeyGeneric, ParentGeneric> extends never ? unknown : ExtractValue<KeyGeneric, ParentGeneric>;
-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 type InnerMappedValues<EntireInputGeneric extends object, MappedValueGeneric> = {
-    [MappedProp in keyof EntireInputGeneric]: MappedValueGeneric;
-};
-export 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 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 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];
-};
-export type NestedBoolean<MatchObject extends object> = Partial<{
-    [Prop in keyof MatchObject]: MatchObject[Prop] extends object ? NestedBoolean<MatchObject[Prop]> | boolean : boolean;
-}>;
-/**
- * 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, noCheckInnerValueOfTheseKeys?: NestedBoolean<typeof compareToThisOne>): asserts testThisOne is MatchThisGeneric;
-export declare function typedObjectFromEntries<KeyType extends PropertyKey, ValueType>(entries: ReadonlyArray<Readonly<[KeyType, ValueType]>>): Record<KeyType, ValueType>;
-export {};
-//# sourceMappingURL=object.d.ts.map

package/dist/types/augments/pick-deep.d.ts

@@ -1,8 +0,0 @@
-import { UnionToIntersection } from 'type-fest';
-import { NestedKeys } from './object/nested-keys';
-type InnerPickDeep<OriginalObjectGeneric extends object, DeepKeys extends any[]> = UnionToIntersection<DeepKeys extends [infer CurrentLevelPick, ...infer RemainingKeys] ? {
-    [CurrentProp in Extract<CurrentLevelPick, keyof OriginalObjectGeneric>]: OriginalObjectGeneric[CurrentProp] extends object ? InnerPickDeep<OriginalObjectGeneric[CurrentProp], RemainingKeys> : OriginalObjectGeneric[CurrentProp];
-} : DeepKeys extends [infer CurrentLevelPick] ? CurrentLevelPick extends keyof OriginalObjectGeneric ? Pick<OriginalObjectGeneric, CurrentLevelPick> : never : never>;
-export type PickDeep<OriginalObjectGeneric extends object, DeepKeys extends NestedKeys<OriginalObjectGeneric>> = InnerPickDeep<OriginalObjectGeneric, DeepKeys>;
-export {};
-//# sourceMappingURL=pick-deep.d.ts.map

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

@@ -1,19 +0,0 @@
-import { AnyFunction } from './function';
-declare function getTypeOf(x: any): "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
-export type TypeOf = ReturnType<typeof getTypeOf>;
-export type TypeOfWithArray = TypeOf | 'array';
-export type TypeOfMapping = {
-    array: any[];
-    bigint: bigint;
-    boolean: boolean;
-    function: AnyFunction;
-    number: number;
-    object: Record<PropertyKey, unknown>;
-    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 {};
-//# sourceMappingURL=type-of.d.ts.map