@augment-vir/common 29.2.0 → 30.0.0

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

@@ -0,0 +1,29 @@
+import { PartialDeep } from 'type-fest';
+/**
+ * Extract all nested object keys and values that are different between the two given objects.
+ *
+ * @returns An empty tuple if the values are equal.
+ */
+export declare function diffObjects<T0 extends Readonly<Record<PropertyKey, unknown>>, T1 extends Readonly<Record<PropertyKey, unknown>>>(object0: T0, object1: T1): [PartialDeep<T0>, PartialDeep<T1>] | [];
+/**
+ * Extract all entries in the given arrays that are not equal.
+ *
+ * @returns An empty tuple if the values are equal.
+ */
+export declare function diffArrays<T0, T1>(array0: ReadonlyArray<T0>, array1: ReadonlyArray<T1>): [Array<T0>, Array<T1>] | [];
+/** Callback for checking equality between two values that can be of different types. */
+export type AreEqualCallback<T0, T1> = (value0: T0, value1: T1) => boolean;
+/**
+ * Simple diff check that is useful simply to return the same format as the other diff functions.
+ *
+ * @returns An empty tuple if the values are equal.
+ */
+export declare function diffBasic<T0, T1>(value0: T0, value1: T1, 
+/** A custom equality checker. Defaults to a strict equality check (`===`). */
+areEqual?: AreEqualCallback<T0, T1>): [T0, T1] | [];
+/**
+ * Diff any values. For diffing objects, use `diffObjects` to get better types.
+ *
+ * @returns An empty tuple if the values are equal.
+ */
+export declare function diffValues<T0, T1>(value0: T0, value1: T1): [T0, T1] | [];

package/dist/augments/object/diff.js

@@ -0,0 +1,133 @@
+import { check } from '@augment-vir/assert';
+import { getObjectTypedKeys } from '@augment-vir/core';
+/**
+ * Extract all nested object keys and values that are different between the two given objects.
+ *
+ * @returns An empty tuple if the values are equal.
+ */
+export function diffObjects(object0, object1) {
+    const allObjectKeys = Array.from(new Set([
+        ...getObjectTypedKeys(object0),
+        ...getObjectTypedKeys(object1),
+    ]));
+    const diffOutput = allObjectKeys.reduce((accum, objectKey) => {
+        const value0 = object0[objectKey];
+        const value1 = object1[objectKey];
+        const diffOutput = diffValues(value0, value1);
+        if (!diffOutput.length) {
+            return accum;
+        }
+        if (!(objectKey in object0)) {
+            accum[1][objectKey] = diffOutput[1];
+        }
+        else if (objectKey in object1) {
+            accum[0][objectKey] = diffOutput[0];
+            accum[1][objectKey] = diffOutput[1];
+        }
+        else {
+            accum[0][objectKey] = diffOutput[0];
+        }
+        return accum;
+    }, [
+        {},
+        {},
+    ]);
+    if (!Object.keys(diffOutput[0]).length && !Object.keys(diffOutput[1]).length) {
+        return [];
+    }
+    else {
+        return diffOutput;
+    }
+}
+/**
+ * Extract all entries in the given arrays that are not equal.
+ *
+ * @returns An empty tuple if the values are equal.
+ */
+export function diffArrays(array0, array1) {
+    const allArrayIndexes = Array.from(new Set([
+        ...Object.keys(array0),
+        ...Object.keys(array1),
+    ].map((index) => Number(index)))).sort();
+    const diffArrays = allArrayIndexes.reduce((accum, arrayIndex) => {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const value0 = array0[arrayIndex];
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const value1 = array1[arrayIndex];
+        const diffOutput = diffValues(value0, value1);
+        if (diffOutput.length) {
+            if (arrayIndex in array0) {
+                accum[0].push(diffOutput[0]);
+            }
+            if (arrayIndex in array1) {
+                accum[1].push(diffOutput[1]);
+            }
+        }
+        return accum;
+    }, [
+        [],
+        [],
+    ]);
+    if (!diffArrays[0].length && !diffArrays[1].length) {
+        return [];
+    }
+    else {
+        return diffArrays;
+    }
+}
+/**
+ * Simple diff check that is useful simply to return the same format as the other diff functions.
+ *
+ * @returns An empty tuple if the values are equal.
+ */
+export function diffBasic(value0, value1, 
+/** A custom equality checker. Defaults to a strict equality check (`===`). */
+areEqual = (value0, value1) => value0 === value1) {
+    if (areEqual(value0, value1)) {
+        return [];
+    }
+    else {
+        return [
+            value0,
+            value1,
+        ];
+    }
+}
+const orderedValueDiffs = [
+    (value0, value1) => {
+        if (!check.isArray(value0) || !check.isArray(value1)) {
+            return undefined;
+        }
+        return diffArrays(value0, value1);
+    },
+    (value0, value1) => {
+        if (!check.instanceOf(value0, RegExp) || !check.instanceOf(value1, RegExp)) {
+            return undefined;
+        }
+        /** Special case RegExps because they should be checked for equality as strings. */
+        return diffBasic(value0, value1, (a, b) => String(a) === String(b));
+    },
+    (value0, value1) => {
+        if (!check.isObject(value0) || !check.isObject(value1)) {
+            return undefined;
+        }
+        return diffObjects(value0, value1);
+    },
+];
+/**
+ * Diff any values. For diffing objects, use `diffObjects` to get better types.
+ *
+ * @returns An empty tuple if the values are equal.
+ */
+export function diffValues(value0, value1) {
+    let diffOutput = undefined;
+    orderedValueDiffs.some((differ) => {
+        diffOutput = differ(value0, value1);
+        return !!diffOutput;
+    });
+    if (diffOutput) {
+        return diffOutput;
+    }
+    /** Fallback to the basic diff. */
+    return diffBasic(value0, value1);
+}

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

@@ -0,0 +1,3 @@
+import { IsEmptyObject } from 'type-fest';
+/** Excludes empty objects from a union. */
+export type ExcludeEmpty<T> = IsEmptyObject<T> extends true ? never : T;

package/dist/augments/object/get-or-set.d.ts

@@ -0,0 +1,31 @@
+import { MaybePromise, type AnyObject } from '@augment-vir/core';
+/**
+ * Get a value from a map or call the callback and return its result and store the result in the
+ * map.
+ *
+ * @category Object:Common
+ */
+export declare function getOrSetFromMap<MapKey extends object, MapValue>(map: WeakMap<MapKey, MapValue>, key: MapKey, createNewValueCallback: () => MapValue): MapValue;
+export declare function getOrSetFromMap<MapKey, MapValue>(map: Map<MapKey, MapValue>, key: MapKey, createNewValueCallback: () => MapValue): MapValue;
+/**
+ * Given an object, tries to get the given key in that object. If the key is not in that object,
+ * then the given `createCallback` is used to create a new value which is then stored in the given
+ * object and returned. Automatically handles `createCallback` returning a promise, if it does.
+ *
+ * @category Object:Common
+ * @example
+ *
+ * ```ts
+ * // instead of doing this
+ * if (!myObject[myKey]) {
+ *     myObject[myKey] = {};
+ * }
+ * myObject[myKey]![nextKey] = 'some value';
+ *
+ * // do this
+ * getOrSetInObject(myObject, myKey, () => {});
+ * ```
+ */
+export declare function getOrSet<OriginalObject extends AnyObject, Key extends keyof OriginalObject>(originalObject: OriginalObject, key: Key, createCallback: () => OriginalObject[Key]): Required<OriginalObject>[Key];
+export declare function getOrSet<OriginalObject extends AnyObject, Key extends keyof OriginalObject>(originalObject: OriginalObject, key: Key, createCallback: () => Promise<OriginalObject[Key]>): Promise<Required<OriginalObject>[Key]>;
+export declare function getOrSet<OriginalObject extends AnyObject, Key extends keyof OriginalObject>(originalObject: OriginalObject, key: Key, createCallback: () => MaybePromise<OriginalObject[Key]>): MaybePromise<Required<OriginalObject>[Key]>;

package/dist/{esm/augments → augments}/object/get-or-set.js

@@ -1,7 +1,9 @@
-import { isPromise } from 'run-time-assertions';
+import { check } from '@augment-vir/assert';
+import { ensureError } from '@augment-vir/core';
 export function getOrSetFromMap(map, key, createNewValueCallback) {
     const mapKey = key;
     if (map.has(mapKey)) {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
         return map.get(mapKey);
     }
     else {
@@ -16,7 +18,7 @@ export function getOrSet(originalObject, key, createCallback) {
     }
     else {
         const createdValue = createCallback();
-        if (isPromise(createdValue)) {
+        if (check.isPromise(createdValue)) {
             return new Promise(async (resolve, reject) => {
                 try {
                     const awaitedValue = await createdValue;
@@ -24,7 +26,7 @@ export function getOrSet(originalObject, key, createCallback) {
                     resolve(awaitedValue);
                 }
                 catch (error) {
-                    reject(error);
+                    reject(ensureError(error));
                 }
             });
         }

package/dist/{types/augments → augments}/object/key-count.d.ts

@@ -1,13 +1,17 @@
-import { UnionToIntersection } from '../union';
-import { AnyObject } from './any-object';
+import type { AnyObject } from '@augment-vir/core';
+/**
+ * Counts the number of unique keys in an object type. Note that a key of just `string` will count
+ * as 1.
+ */
+export type KeyCount<T extends AnyObject> = UnionToTuple<keyof T>['length'];
 /**
  * This is not exported because its order is not stable but it's okay for our simple use case where
  * we simply want to count the size of the union.
  */
 type UnionToTuple<T> = UnionToIntersection<T extends any ? (t: T) => T : never> extends (args: any) => infer W ? [...UnionToTuple<Exclude<T, W>>, W] : [];
 /**
- * Counts the number of unique keys in an object type. Note that a key of just `string` will count
- * as 1.
+ * This is the version of UnionToIntersection from type-fest v4.3.3. In version 4.4.0 type-fest
+ * changed this type helper and it broke how we're using it.
  */
-export type KeyCount<T extends AnyObject> = UnionToTuple<keyof T>['length'];
+type UnionToIntersection<Union> = (Union extends unknown ? (distributedUnion: Union) => void : never) extends (mergedIntersection: infer Intersection) => void ? Intersection : never;
 export {};

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

@@ -0,0 +1,13 @@
+import { Values, type MaybePromise } from '@augment-vir/core';
+export declare function mapObject<const OriginalObject, const NewKey extends PropertyKey, const NewValue>(inputObject: OriginalObject, mapCallback: (originalKey: keyof OriginalObject, originalValue: Values<OriginalObject>, originalObject: OriginalObject) => Promise<{
+    key: NewKey;
+    value: NewValue;
+} | undefined>): Promise<Record<NewKey, NewValue>>;
+export declare function mapObject<const OriginalObject, const NewKey extends PropertyKey, const NewValue>(inputObject: OriginalObject, mapCallback: (originalKey: keyof OriginalObject, originalValue: Values<OriginalObject>, originalObject: OriginalObject) => {
+    key: NewKey;
+    value: NewValue;
+} | undefined): Record<NewKey, NewValue>;
+export declare function mapObject<const OriginalObject, const NewKey extends PropertyKey, const NewValue>(inputObject: OriginalObject, mapCallback: (originalKey: keyof OriginalObject, originalValue: Values<OriginalObject>, originalObject: OriginalObject) => MaybePromise<{
+    key: NewKey;
+    value: NewValue;
+} | undefined>): MaybePromise<Record<NewKey, NewValue>>;

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

@@ -0,0 +1,57 @@
+import { check } from '@augment-vir/assert';
+import { ensureError } from '@augment-vir/core';
+import { filterMap } from '../array/filter.js';
+import { getObjectTypedEntries, typedObjectFromEntries } from './object-entries.js';
+export function mapObject(originalObject, mapCallback) {
+    try {
+        let gotAPromise = false;
+        const mappedEntries = getObjectTypedEntries(originalObject)
+            .map(([originalKey, originalValue,]) => {
+            const output = mapCallback(originalKey, originalValue, originalObject);
+            if (output instanceof Promise) {
+                gotAPromise = true;
+                return output;
+            }
+            else if (output) {
+                return [
+                    output.key,
+                    output.value,
+                ];
+            }
+            else {
+                return undefined;
+            }
+        })
+            .filter(check.isTruthy);
+        if (gotAPromise) {
+            return new Promise(async (resolve, reject) => {
+                try {
+                    const entries = filterMap(await Promise.all(mappedEntries), (entry) => {
+                        if (!entry) {
+                            return undefined;
+                        }
+                        else if (Array.isArray(entry)) {
+                            return entry;
+                        }
+                        else {
+                            return [
+                                entry.key,
+                                entry.value,
+                            ];
+                        }
+                    }, check.isTruthy);
+                    resolve(typedObjectFromEntries(entries));
+                }
+                catch (error) {
+                    reject(ensureError(error));
+                }
+            });
+        }
+        else {
+            return typedObjectFromEntries(mappedEntries);
+        }
+    }
+    catch (error) {
+        throw ensureError(error);
+    }
+}

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

@@ -0,0 +1,4 @@
+import type { EnumBaseType, MaybePromise, Values } from '@augment-vir/core';
+export type EnumMap<Enum extends EnumBaseType, Value> = Values<Enum> extends PropertyKey ? Record<Values<Enum>, Value> : 'ERROR: invalid enum';
+export declare function mapEnumToObject<const Enum extends EnumBaseType, const Value>(enumInput: Enum, callback: (enumValue: Values<Enum>) => Promise<Value>): Promise<EnumMap<Enum, Value>>;
+export declare function mapEnumToObject<const Enum extends EnumBaseType, const Value>(enumInput: Enum, callback: (enumValue: Values<Enum>, wholeEnum: Enum) => Value): Value extends Promise<any> ? Promise<any> extends Value ? Promise<EnumMap<Enum, Awaited<Value>>> : MaybePromise<EnumMap<Enum, Awaited<Value>>> : EnumMap<Enum, Value>;

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

@@ -0,0 +1,21 @@
+import { mapObject } from './map-entries.js';
+export function mapEnumToObject(enumInput, callback) {
+    return mapObject(enumInput, (enumKey, enumValue) => {
+        const key = enumValue;
+        const value = callback(enumValue, enumInput);
+        if (value instanceof Promise) {
+            return value.then((resolvedValue) => {
+                return {
+                    key,
+                    value: resolvedValue,
+                };
+            });
+        }
+        else {
+            return {
+                key,
+                value,
+            };
+        }
+    });
+}

package/dist/{types/augments/object/map-object.d.ts → augments/object/map-values.d.ts}

@@ -1,4 +1,4 @@
-import { PropertyValueType } from './object';
+import { type Values } from '@augment-vir/core';
 export type InnerMappedValues<EntireInputGeneric extends object, MappedValueGeneric> = {
     [MappedProp in keyof EntireInputGeneric]: MappedValueGeneric;
 };
@@ -10,9 +10,12 @@ export type MappedValues<EntireInputGeneric extends object, MappedValueGeneric>
  * to explicitly state the return type.
  *
  * @example
- *     mapObjectValuesSync({objectToIterateOver: 'initial value'})(callback);
+ *
+ * ```ts
+ * mapObjectValuesSync({objectToIterateOver: 'initial value'})(callback);
+ * ```
  */
-export declare function mapObjectValuesSync<EntireInputGeneric extends object>(inputObject: EntireInputGeneric): <OutputObjectGeneric extends object>(mapCallback: (inputKey: keyof EntireInputGeneric, keyValue: Required<EntireInputGeneric>[typeof inputKey], fullObject: EntireInputGeneric) => never extends PropertyValueType<OutputObjectGeneric> ? any : PropertyValueType<OutputObjectGeneric>) => OutputObjectGeneric;
+export declare function mapObjectValuesSync<EntireInputGeneric extends object>(inputObject: EntireInputGeneric): <OutputObjectGeneric extends object>(mapCallback: (inputKey: keyof EntireInputGeneric, keyValue: Required<EntireInputGeneric>[typeof inputKey], fullObject: EntireInputGeneric) => never extends Values<OutputObjectGeneric> ? any : Values<OutputObjectGeneric>) => OutputObjectGeneric;
 /**
  * Creates a new object with the same properties as the input object, but with values set to the
  * result of mapCallback for each property.

package/dist/{esm/augments/object/map-object.js → augments/object/map-values.js}

@@ -1,4 +1,4 @@
-import { getObjectTypedKeys } from './object-entries';
+import { ensureError, getObjectTypedKeys } from '@augment-vir/core';
 /**
  * Map an object's keys to new values synchronously. This is different from plain mapObjectValues in
  * that this will not wrap the return value in a promise if any of the new object values are
@@ -6,18 +6,20 @@ import { getObjectTypedKeys } from './object-entries';
  * to explicitly state the return type.
  *
  * @example
- *     mapObjectValuesSync({objectToIterateOver: 'initial value'})(callback);
+ *
+ * ```ts
+ * mapObjectValuesSync({objectToIterateOver: 'initial value'})(callback);
+ * ```
  */
 export function mapObjectValuesSync(inputObject) {
     function innerMap(mapCallback) {
-        const mappedObject = getObjectTypedKeys(inputObject).reduce((accum, currentKey) => {
+        return getObjectTypedKeys(inputObject).reduce((accum, currentKey) => {
             const mappedValue = mapCallback(currentKey, inputObject[currentKey], inputObject);
             return {
                 ...accum,
                 [currentKey]: mappedValue,
             };
         }, {});
-        return mappedObject;
     }
     return innerMap;
 }
@@ -32,10 +34,8 @@ export function mapObjectValues(inputObject, mapCallback) {
         if (mappedValue instanceof Promise) {
             gotAPromise = true;
         }
-        return {
-            ...accum,
-            [currentKey]: mappedValue,
-        };
+        accum[currentKey] = mappedValue;
+        return accum;
     }, {});
     if (gotAPromise) {
         return new Promise(async (resolve, reject) => {
@@ -47,7 +47,7 @@ export function mapObjectValues(inputObject, mapCallback) {
                 resolve(mappedObject);
             }
             catch (error) {
-                reject(error);
+                reject(ensureError(error));
             }
         });
     }

package/dist/{esm/augments → augments}/object/merge-deep.js

@@ -1,5 +1,4 @@
-import { isRunTimeType } from 'run-time-assertions';
-import { isLengthAtLeast } from '../tuple';
+import { check } from '@augment-vir/assert';
 /**
  * Accepts multiple objects and merges their key-value pairs recursively. Any values set to
  * undefined will be removed.
@@ -7,7 +6,7 @@ import { isLengthAtLeast } from '../tuple';
  * Note that order matters! Each input object will overwrite the properties of the previous objects.
  */
 export function mergeDeep(...inputs) {
-    if (!isLengthAtLeast(inputs, 1)) {
+    if (!check.isLengthAtLeast(inputs, 1)) {
         // nothing to merge if no inputs
         return {};
     }
@@ -18,12 +17,12 @@ export function mergeDeep(...inputs) {
     let result = undefined;
     const mergeProps = {};
     inputs.forEach((individualInput) => {
-        if (!isRunTimeType(individualInput, 'object')) {
+        if (!check.isObject(individualInput)) {
             /** If not an object, we can't merge. So overwrite instead. */
             result = individualInput;
             return;
         }
-        else if (!isRunTimeType(result, 'object')) {
+        else if (!check.isObject(result)) {
             /** If result isn't an object then we need to make it into one. */
             result = { ...individualInput };
         }
@@ -34,7 +33,7 @@ export function mergeDeep(...inputs) {
             mergeProps[key].push(value);
         });
     });
-    if (isRunTimeType(result, 'object')) {
+    if (check.isObject(result)) {
         Object.entries(mergeProps).forEach(([key, mergeValues,]) => {
             const newValue = mergeDeep(...mergeValues);
             if (newValue === undefined && key in result) {

package/dist/augments/object/merge-defined-properties.d.ts

@@ -0,0 +1,6 @@
+import type { AnyObject, PartialWithNullable } from '@augment-vir/core';
+/**
+ * Merge all objects together but ignore any override values that are `undefined` or `null` or
+ * missing. This only merges objects at the top level, it is not a deep merge.
+ */
+export declare function mergeDefinedProperties<const T extends AnyObject>(original: T, ...overrides: ReadonlyArray<PartialWithNullable<NoInfer<T>> | undefined>): T;

package/dist/augments/object/merge-defined-properties.js

@@ -0,0 +1,19 @@
+import { getObjectTypedEntries } from './object-entries.js';
+/**
+ * Merge all objects together but ignore any override values that are `undefined` or `null` or
+ * missing. This only merges objects at the top level, it is not a deep merge.
+ */
+export function mergeDefinedProperties(original, ...overrides) {
+    const finalObject = { ...original };
+    overrides.forEach((entry) => {
+        if (!entry) {
+            return;
+        }
+        getObjectTypedEntries(entry).forEach(([key, value,]) => {
+            if (value != undefined) {
+                finalObject[key] = value;
+            }
+        });
+    });
+    return finalObject;
+}

package/dist/{esm/augments → augments}/object/merge-property-arrays.js

@@ -1,4 +1,4 @@
-import { getOrSet } from './get-or-set';
+import { getOrSet } from './get-or-set.js';
 export function mergePropertyArrays(...inputs) {
     const combined = {};
     inputs.forEach((input) => {

package/dist/augments/object/object-entries.d.ts

@@ -0,0 +1,4 @@
+import { CompleteRequire } from '@augment-vir/core';
+export declare function getObjectTypedEntries<const ObjectGeneric>(input: ObjectGeneric): [keyof ObjectGeneric, CompleteRequire<ObjectGeneric>[keyof CompleteRequire<ObjectGeneric>]][];
+export declare function typedObjectFromEntries<const KeyType extends PropertyKey, const ValueType>(entries: ReadonlyArray<Readonly<[KeyType, ValueType]>>): Record<KeyType, ValueType>;
+export declare function getEntriesSortedByKey<const ObjectGeneric>(input: ObjectGeneric): [keyof ObjectGeneric, CompleteRequire<ObjectGeneric>[keyof CompleteRequire<ObjectGeneric>]][];

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

@@ -0,0 +1,13 @@
+import { getObjectTypedKeys } from '@augment-vir/core';
+export function getObjectTypedEntries(input) {
+    return getObjectTypedKeys(input).map((key) => [
+        key,
+        input[key],
+    ]);
+}
+export function typedObjectFromEntries(entries) {
+    return Object.fromEntries(entries);
+}
+export function getEntriesSortedByKey(input) {
+    return getObjectTypedEntries(input).sort((tupleA, tupleB) => String(tupleA[0]).localeCompare(String(tupleB[0])));
+}

package/dist/augments/object/object-filter.d.ts

@@ -0,0 +1,2 @@
+import { type Values } from '@augment-vir/core';
+export declare function filterObject<ObjectGeneric>(inputObject: ObjectGeneric, callback: (key: keyof ObjectGeneric, value: Values<ObjectGeneric>, fullObject: ObjectGeneric) => boolean): Partial<ObjectGeneric>;

package/dist/augments/object/object-filter.js

@@ -0,0 +1,7 @@
+import { getObjectTypedEntries, typedObjectFromEntries } from './object-entries.js';
+export function filterObject(inputObject, callback) {
+    const filteredEntries = getObjectTypedEntries(inputObject).filter(([key, value,]) => {
+        return callback(key, value, inputObject);
+    });
+    return typedObjectFromEntries(filteredEntries);
+}

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

@@ -0,0 +1,2 @@
+export declare function omitObjectKeys<const ObjectGeneric, const KeyGeneric extends keyof ObjectGeneric>(inputObject: Readonly<ObjectGeneric>, omitTheseKeys: ReadonlyArray<KeyGeneric>): Omit<ObjectGeneric, KeyGeneric>;
+export declare function pickObjectKeys<const ObjectGeneric, const KeyGeneric extends keyof ObjectGeneric>(inputObject: Readonly<ObjectGeneric>, pickTheseKeys: ReadonlyArray<KeyGeneric>): Pick<ObjectGeneric, KeyGeneric>;

package/dist/augments/object/object-keys.js

@@ -0,0 +1,11 @@
+import { filterObject } from './object-filter.js';
+export function omitObjectKeys(inputObject, omitTheseKeys) {
+    return filterObject(inputObject, (currentKey) => {
+        return !omitTheseKeys.includes(currentKey);
+    });
+}
+export function pickObjectKeys(inputObject, pickTheseKeys) {
+    return filterObject(inputObject, (currentKey) => {
+        return pickTheseKeys.includes(currentKey);
+    });
+}

package/dist/augments/object/object-values.d.ts

@@ -0,0 +1,2 @@
+import { CompleteRequire } from '@augment-vir/core';
+export declare function getObjectTypedValues<ObjectGeneric>(input: ObjectGeneric): CompleteRequire<ObjectGeneric>[keyof CompleteRequire<ObjectGeneric>][];

package/dist/augments/object/object-values.js

@@ -0,0 +1,4 @@
+import { getObjectTypedKeys } from '@augment-vir/core';
+export function getObjectTypedValues(input) {
+    return getObjectTypedKeys(input).map((key) => input[key]);
+}