@augment-vir/common 7.1.0 → 8.1.0

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

@@ -1,5 +1,5 @@
 import { UnionToIntersection } from 'type-fest';
-import { ObjectValueType } from './object';
+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];
 }>;

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

@@ -0,0 +1,5 @@
+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 filterToEnumValues<T extends object>(inputs: ReadonlyArray<unknown>, checkEnum: T, caseInsensitive?: boolean): T[keyof T][];
+//# sourceMappingURL=enum.d.ts.map

package/dist/cjs/augments/object/enum.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filterToEnumValues = exports.isEnumValue = exports.getEnumTypedValues = exports.getEnumTypedKeys = void 0;
+const object_entries_1 = require("./object-entries");
+function getEnumTypedKeys(input) {
+    // enum keys are always strings
+    return (0, object_entries_1.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 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;

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

@@ -0,0 +1,11 @@
+import { UnPromise } from '../type';
+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>;
+//# sourceMappingURL=map-object.d.ts.map

package/dist/cjs/augments/object/map-object.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapObjectValues = void 0;
+const object_entries_1 = require("./object-entries");
+/**
+ * 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 = (0, object_entries_1.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((0, object_entries_1.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;

package/dist/cjs/augments/object/matches-object-shape.d.ts

@@ -0,0 +1,37 @@
+import { AtLeastOneEntryArray } from '../array';
+import { NoInfer } from '../type';
+/**
+ * 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;
+//# sourceMappingURL=matches-object-shape.d.ts.map

package/dist/cjs/augments/object/matches-object-shape.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertMatchesObjectShape = exports.matchesObjectShape = void 0;
+const error_1 = require("../error");
+const function_1 = require("../function");
+const object_1 = require("./object");
+const object_entries_1 = require("./object-entries");
+const typed_has_property_1 = require("./typed-has-property");
+/**
+ * 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 = (0, object_entries_1.getObjectTypedKeys)(testThisOne);
+    const matchKeys = new Set((0, object_entries_1.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 (!(0, typed_has_property_1.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 ((0, typed_has_property_1.typedHasProperty)(matchValue, 'constructor')) {
+            if (!(0, typed_has_property_1.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 ((0, object_1.isObject)(matchValue)) {
+        assertMatchesObjectShape(testValue, matchValue, allowExtraProps, noCheckInnerValueOfTheseKeys);
+    }
+}

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

@@ -0,0 +1,12 @@
+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/object/nested-keys.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getValueFromNestedKeys = void 0;
+const typed_has_property_1 = require("./typed-has-property");
+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, typed_has_property_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/object-entries.d.ts

@@ -0,0 +1,6 @@
+export declare function isKeyof<ObjectGeneric>(key: PropertyKey, object: ObjectGeneric): key is keyof ObjectGeneric;
+export declare function getObjectTypedKeys<ObjectGeneric extends unknown>(input: ObjectGeneric): Array<keyof ObjectGeneric>;
+export declare function getObjectTypedValues<ObjectGeneric extends unknown>(input: ObjectGeneric): ObjectGeneric[keyof ObjectGeneric][];
+export declare function getEntriesSortedByKey(input: object): [string, unknown][];
+export declare function typedObjectFromEntries<KeyType extends PropertyKey, ValueType>(entries: ReadonlyArray<Readonly<[KeyType, ValueType]>>): Record<KeyType, ValueType>;
+//# sourceMappingURL=object-entries.d.ts.map

package/dist/cjs/augments/object/object-entries.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.typedObjectFromEntries = exports.getEntriesSortedByKey = exports.getObjectTypedValues = exports.getObjectTypedKeys = exports.isKeyof = void 0;
+const typed_has_property_1 = require("./typed-has-property");
+function isKeyof(key, object) {
+    return (0, typed_has_property_1.typedHasProperty)(object, key);
+}
+exports.isKeyof = isKeyof;
+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;
+function getEntriesSortedByKey(input) {
+    return Object.entries(input).sort((tupleA, tupleB) => tupleA[0].localeCompare(tupleB[0]));
+}
+exports.getEntriesSortedByKey = getEntriesSortedByKey;
+function typedObjectFromEntries(entries) {
+    return Object.fromEntries(entries);
+}
+exports.typedObjectFromEntries = typedObjectFromEntries;

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

@@ -0,0 +1,10 @@
+export type PartialWithNullable<T extends object> = {
+    [Prop in keyof T]?: T[Prop] | null | undefined;
+};
+export declare function isObject(input: any): input is NonNullable<object>;
+export declare function areJsonEqual(a: object, b: object): boolean;
+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];
+//# sourceMappingURL=object.d.ts.map

package/dist/cjs/augments/object/object.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.copyThroughJson = exports.filterObject = exports.areJsonEqual = exports.isObject = void 0;
+const object_entries_1 = require("./object-entries");
+function isObject(input) {
+    return !!input && typeof input === 'object';
+}
+exports.isObject = isObject;
+function areJsonEqual(a, b) {
+    try {
+        const sortedAEntries = (0, object_entries_1.getEntriesSortedByKey)(a);
+        const sortedBEntries = (0, object_entries_1.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;
+function filterObject(inputObject, callback) {
+    const filteredKeys = (0, object_entries_1.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;

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

@@ -0,0 +1,8 @@
+import { UnionToIntersection } from 'type-fest';
+import { NestedKeys } from './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/object/pick-deep.js

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

package/dist/cjs/augments/object/typed-has-property.d.ts

@@ -0,0 +1,8 @@
+import { RequiredBy } from '../type';
+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 {};
+//# sourceMappingURL=typed-has-property.d.ts.map

package/dist/cjs/augments/object/typed-has-property.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.typedHasProperties = exports.typedHasProperty = void 0;
+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;

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

@@ -1,5 +1,5 @@
 import { UnionToIntersection } from 'type-fest';
-import { NestedKeys } from './nested-keys';
+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>;

package/dist/cjs/augments/promise.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.waitForCondition = exports.createDeferredPromiseWrapper = exports.wrapPromiseInTimeout = exports.PromiseTimeoutError = exports.isPromiseLike = exports.wait = void 0;
 const error_1 = require("./error");
-const object_1 = require("./object");
+const typed_has_property_1 = require("./object/typed-has-property");
 function wait(delayMs) {
     const deferredPromiseWrapper = createDeferredPromiseWrapper();
     if (delayMs !== Infinity) {
@@ -14,7 +14,7 @@ function wait(delayMs) {
 }
 exports.wait = wait;
 function isPromiseLike(input) {
-    if ((0, object_1.typedHasProperty)(input, 'then') && typeof input.then === 'function') {
+    if ((0, typed_has_property_1.typedHasProperty)(input, 'then') && typeof input.then === 'function') {
         return true;
     }
     else {
@@ -33,9 +33,11 @@ class PromiseTimeoutError extends Error {
 exports.PromiseTimeoutError = PromiseTimeoutError;
 function wrapPromiseInTimeout(durationMs, originalPromise) {
     return new Promise(async (resolve, reject) => {
-        const timeoutId = setTimeout(() => {
-            reject(new PromiseTimeoutError(durationMs));
-        }, durationMs);
+        const timeoutId = durationMs === Infinity
+            ? undefined
+            : setTimeout(() => {
+                reject(new PromiseTimeoutError(durationMs));
+            }, durationMs);
         try {
             const result = await originalPromise;
             resolve(result);

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

@@ -0,0 +1,20 @@
+import { AnyFunction } from './function';
+declare function rawGetTypeOf(x: any): "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
+type RawTypeOf = ReturnType<typeof rawGetTypeOf>;
+export type RuntimeTypeOf = RawTypeOf | 'array';
+export type RuntimeTypeOfMapping = {
+    array: any[];
+    bigint: bigint;
+    boolean: boolean;
+    function: AnyFunction;
+    number: number;
+    object: Record<PropertyKey, unknown>;
+    string: string;
+    symbol: symbol;
+    undefined: undefined;
+};
+export declare function getRuntimeTypeOf(input: unknown): RuntimeTypeOf;
+export declare function isRuntimeTypeOf<T extends RuntimeTypeOf>(input: unknown, testType: T): input is RuntimeTypeOfMapping[T];
+export declare function assertRuntimeTypeOf<T extends RuntimeTypeOf>(input: unknown, testType: T): asserts input is RuntimeTypeOfMapping[T];
+export {};
+//# sourceMappingURL=runtime-type-of.d.ts.map

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

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertRuntimeTypeOf = exports.isRuntimeTypeOf = exports.getRuntimeTypeOf = void 0;
+// this function is not used at run time, it's only here for types
+// istanbul ignore next
+function rawGetTypeOf(x) {
+    return typeof x;
+}
+function getRuntimeTypeOf(input) {
+    return Array.isArray(input) ? 'array' : typeof input;
+}
+exports.getRuntimeTypeOf = getRuntimeTypeOf;
+function isRuntimeTypeOf(input, testType) {
+    const inputType = getRuntimeTypeOf(input);
+    return inputType === testType;
+}
+exports.isRuntimeTypeOf = isRuntimeTypeOf;
+function assertRuntimeTypeOf(input, testType) {
+    if (!isRuntimeTypeOf(input, testType)) {
+        throw new TypeError(`'${input}' is not of type '${testType}'`);
+    }
+}
+exports.assertRuntimeTypeOf = assertRuntimeTypeOf;

package/dist/cjs/index.d.ts

@@ -7,13 +7,18 @@ export * from './augments/date';
 export * from './augments/environment';
 export * from './augments/error';
 export * from './augments/function';
-export * from './augments/nested-keys';
-export * from './augments/object';
-export * from './augments/pick-deep';
+export * from './augments/object/enum';
+export * from './augments/object/map-object';
+export * from './augments/object/matches-object-shape';
+export * from './augments/object/nested-keys';
+export * from './augments/object/object';
+export * from './augments/object/object-entries';
+export * from './augments/object/pick-deep';
+export * from './augments/object/typed-has-property';
 export * from './augments/promise';
 export * from './augments/regexp';
+export * from './augments/runtime-type-of';
 export * from './augments/truncate-number';
 export * from './augments/tuple';
 export * from './augments/type';
-export * from './augments/type-of';
 //# sourceMappingURL=index.d.ts.map

package/dist/cjs/index.js

@@ -23,12 +23,17 @@ __exportStar(require("./augments/date"), exports);
 __exportStar(require("./augments/environment"), exports);
 __exportStar(require("./augments/error"), exports);
 __exportStar(require("./augments/function"), exports);
-__exportStar(require("./augments/nested-keys"), exports);
-__exportStar(require("./augments/object"), exports);
-__exportStar(require("./augments/pick-deep"), exports);
+__exportStar(require("./augments/object/enum"), exports);
+__exportStar(require("./augments/object/map-object"), exports);
+__exportStar(require("./augments/object/matches-object-shape"), exports);
+__exportStar(require("./augments/object/nested-keys"), exports);
+__exportStar(require("./augments/object/object"), exports);
+__exportStar(require("./augments/object/object-entries"), exports);
+__exportStar(require("./augments/object/pick-deep"), exports);
+__exportStar(require("./augments/object/typed-has-property"), exports);
 __exportStar(require("./augments/promise"), exports);
 __exportStar(require("./augments/regexp"), exports);
+__exportStar(require("./augments/runtime-type-of"), exports);
 __exportStar(require("./augments/truncate-number"), exports);
 __exportStar(require("./augments/tuple"), exports);
 __exportStar(require("./augments/type"), exports);
-__exportStar(require("./augments/type-of"), exports);

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

@@ -1,5 +1,5 @@
 import { UnionToIntersection } from 'type-fest';
-import { ObjectValueType } from './object';
+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];
 }>;

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

@@ -0,0 +1,5 @@
+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 filterToEnumValues<T extends object>(inputs: ReadonlyArray<unknown>, checkEnum: T, caseInsensitive?: boolean): T[keyof T][];
+//# sourceMappingURL=enum.d.ts.map

package/dist/esm/augments/object/enum.js

@@ -0,0 +1,30 @@
+import { getObjectTypedKeys } from './object-entries';
+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 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));
+    }
+}