@augment-vir/common 29.3.0 → 30.0.1

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

@@ -0,0 +1,10 @@
+import { MaybePromise, type AnyObject } from '@augment-vir/core';
+export declare function getOrSetFromMap<MapKey extends object, MapValue>(map: WeakMap<MapKey, MapValue>, key: MapKey, createCallback: () => MapValue): MapValue;
+export declare function getOrSetFromMap<MapKey, MapValue>(map: Map<MapKey, MapValue>, key: MapKey, createCallback: () => MapValue): MapValue;
+export declare function getOrSetFromMap<MapKey extends object, MapValue>(map: WeakMap<MapKey, MapValue>, key: MapKey, createCallback: () => Promise<MapValue>): Promise<MapValue>;
+export declare function getOrSetFromMap<MapKey, MapValue>(map: Map<MapKey, MapValue>, key: MapKey, createCallback: () => Promise<MapValue>): Promise<MapValue>;
+export declare function getOrSetFromMap<MapKey extends object, MapValue>(map: WeakMap<MapKey, MapValue>, key: MapKey, createCallback: () => MaybePromise<MapValue>): MaybePromise<MapValue>;
+export declare function getOrSetFromMap<MapKey, MapValue>(map: Map<MapKey, MapValue>, key: MapKey, createCallback: () => MaybePromise<MapValue>): MaybePromise<MapValue>;
+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/augments/object/get-or-set.js

@@ -0,0 +1,100 @@
+import { check } from '@augment-vir/assert';
+import { ensureError } from '@augment-vir/core';
+/**
+ * Given an map, tries to get the given key in that map. If the key is not in that map, then the
+ * given `createCallback` is used to create a new value which is then stored in the given map and
+ * returned. Automatically handles an async `createCallback`.
+ *
+ * @category Object
+ * @category Package : @augment-vir/common
+ * @example
+ *
+ * ```ts
+ * // instead of doing this
+ * if (!myMap.get(myKey)) {
+ *     myMap.set(myKey, {});
+ * }
+ * myMap.get(myKey)![nextKey] = 'some value';
+ *
+ * // do this
+ * getOrSetInObject(myMap, myKey, () => {
+ *     return {};
+ * });
+ * ```
+ *
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export function getOrSetFromMap(map, key, createCallback) {
+    const mapKey = key;
+    if (map.has(mapKey)) {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        return map.get(mapKey);
+    }
+    else {
+        const createdValue = createCallback();
+        if (check.isPromise(createdValue)) {
+            return new Promise(async (resolve, reject) => {
+                try {
+                    const awaitedValue = await createdValue;
+                    map.set(mapKey, awaitedValue);
+                    resolve(awaitedValue);
+                }
+                catch (error) {
+                    reject(ensureError(error));
+                }
+            });
+        }
+        else {
+            map.set(mapKey, createdValue);
+            return createdValue;
+        }
+    }
+}
+/**
+ * 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 an async `createCallback`.
+ *
+ * @category Object
+ * @category Package : @augment-vir/common
+ * @example
+ *
+ * ```ts
+ * // instead of doing this
+ * if (!myObject[myKey]) {
+ *     myObject[myKey] = {};
+ * }
+ * myObject[myKey]![nextKey] = 'some value';
+ *
+ * // do this
+ * getOrSetInObject(myObject, myKey, () => {
+ *     return {};
+ * });
+ * ```
+ *
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export function getOrSet(originalObject, key, createCallback) {
+    if (key in originalObject) {
+        return originalObject[key];
+    }
+    else {
+        const createdValue = createCallback();
+        if (check.isPromise(createdValue)) {
+            return new Promise(async (resolve, reject) => {
+                try {
+                    const awaitedValue = await createdValue;
+                    originalObject[key] = awaitedValue;
+                    resolve(awaitedValue);
+                }
+                catch (error) {
+                    reject(ensureError(error));
+                }
+            });
+        }
+        else {
+            originalObject[key] = createdValue;
+            return createdValue;
+        }
+    }
+}

package/dist/augments/object/key-count.d.ts

@@ -0,0 +1,21 @@
+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.
+ *
+ * @category Object
+ * @category Package : @augment-vir/common
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+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] : [];
+/**
+ * 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.
+ */
+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,80 @@
+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';
+/**
+ * Maps an object. The callback must return a key and value.
+ *
+ * @category Object
+ * @category Package : @augment-vir/common
+ * @example
+ *
+ * ```ts
+ * import {mapObject} from '@augment-vir/common';
+ *
+ * mapObject({a: 1, b: 2}, (key, value) => {
+ *     return {
+ *         key: `key-${key}`,
+ *         value: `value-${value}`,
+ *     };
+ * });
+ * // output is `{'key-a': 'value-1', 'key-b': 'value-2'}`
+ * ```
+ *
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ * @see
+ * - {@link mapObjectValues}: the variant that only maps values.
+ */
+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,11 @@
+import type { EnumBaseType, MaybePromise, Values } from '@augment-vir/core';
+/**
+ * Creates an object that maps all values of an enum to the provided `Values` type.
+ *
+ * @category Object
+ * @category Package : @augment-vir/common
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+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,45 @@
+import { mapObject } from './map-entries.js';
+/**
+ * Maps all values of an enum as keys in an object where each value is the callback's output for
+ * that key.
+ *
+ * @category Object
+ * @category Package : @augment-vir/common
+ * @example
+ *
+ * ```ts
+ * import {mapEnumToObject} from '@augment-vir/common';
+ *
+ * enum MyEnum {
+ *     A = 'a',
+ *     B = 'b',
+ * }
+ *
+ * mapEnumToObject(MyEnum, (enumValue) => {
+ *     return `value-${enumValue}`;
+ * });
+ * // output is `{[MyEnum.A]: 'value-a', [MyEnum.B]: 'value-b'}`
+ * ```
+ *
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+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/augments/object/map-values.d.ts

@@ -0,0 +1,35 @@
+type InnerMappedValues<EntireInputGeneric extends object, MappedValueGeneric> = {
+    [MappedProp in keyof EntireInputGeneric]: MappedValueGeneric;
+};
+type MappedValues<EntireInputGeneric extends object, MappedValueGeneric> = MappedValueGeneric extends PromiseLike<unknown> ? Promise<InnerMappedValues<EntireInputGeneric, Awaited<MappedValueGeneric>>> : InnerMappedValues<EntireInputGeneric, Awaited<MappedValueGeneric>>;
+/**
+ * Creates a new object with the same keys as the input object, but with values set to the result of
+ * `mapCallback` for each property. This is the same as {@link mapObjectValues} except that this
+ * preserves Promise values: it doesn't wrap them all in a single promise.
+ *
+ * @category Object
+ * @category Package : @augment-vir/common
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export declare function mapObjectValuesSync<EntireInputGeneric extends object, MappedValueGeneric>(inputObject: EntireInputGeneric, mapCallback: (inputKey: keyof EntireInputGeneric, keyValue: Required<EntireInputGeneric>[typeof inputKey], fullObject: EntireInputGeneric) => MappedValueGeneric): InnerMappedValues<EntireInputGeneric, MappedValueGeneric>;
+/**
+ * Creates a new object with the same keys as the input object, but with values set to the result of
+ * `mapCallback` for each property. Automatically handles an async `mapCallback`.
+ *
+ * @category Object
+ * @category Package : @augment-vir/common
+ * @example
+ *
+ * ```ts
+ * import {mapObjectValues} from '@augment-vir/common';
+ *
+ * mapObjectValues({a: 1, b: 2}, (key, value) => {
+ *     return `key-${key} value-${value}`;
+ * });
+ * // output is `{a: 'key-a value-1', b: 'key-b value-2'}`
+ * ```
+ *
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export declare function mapObjectValues<EntireInputGeneric extends object, MappedValueGeneric>(inputObject: EntireInputGeneric, mapCallback: (inputKey: keyof EntireInputGeneric, keyValue: Required<EntireInputGeneric>[typeof inputKey], fullObject: EntireInputGeneric) => MappedValueGeneric): MappedValues<EntireInputGeneric, MappedValueGeneric>;
+export {};

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

@@ -0,0 +1,65 @@
+import { ensureError, getObjectTypedKeys } from '@augment-vir/core';
+/**
+ * Creates a new object with the same keys as the input object, but with values set to the result of
+ * `mapCallback` for each property. This is the same as {@link mapObjectValues} except that this
+ * preserves Promise values: it doesn't wrap them all in a single promise.
+ *
+ * @category Object
+ * @category Package : @augment-vir/common
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export function mapObjectValuesSync(inputObject, mapCallback) {
+    const mappedObject = getObjectTypedKeys(inputObject).reduce((accum, currentKey) => {
+        const mappedValue = mapCallback(currentKey, inputObject[currentKey], inputObject);
+        accum[currentKey] = mappedValue;
+        return accum;
+    }, {});
+    return mappedObject;
+}
+/**
+ * Creates a new object with the same keys as the input object, but with values set to the result of
+ * `mapCallback` for each property. Automatically handles an async `mapCallback`.
+ *
+ * @category Object
+ * @category Package : @augment-vir/common
+ * @example
+ *
+ * ```ts
+ * import {mapObjectValues} from '@augment-vir/common';
+ *
+ * mapObjectValues({a: 1, b: 2}, (key, value) => {
+ *     return `key-${key} value-${value}`;
+ * });
+ * // output is `{a: 'key-a value-1', b: 'key-b value-2'}`
+ * ```
+ *
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+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;
+        }
+        accum[currentKey] = mappedValue;
+        return accum;
+    }, {});
+    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(ensureError(error));
+            }
+        });
+    }
+    else {
+        return mappedObject;
+    }
+}

package/dist/{types/augments → augments}/object/merge-deep.d.ts

@@ -4,6 +4,10 @@ import { PartialDeep } from 'type-fest';
  * undefined will be removed.
  *
  * Note that order matters! Each input object will overwrite the properties of the previous objects.
+ *
+ * @category Object : Merge
+ * @category Package : @augment-vir/common
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
  */
 export declare function mergeDeep<const T extends object>(...inputs: (Readonly<T> | Readonly<PartialDeep<T, {
     recurseIntoArrays: true;

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

@@ -1,13 +1,16 @@
-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.
  *
  * Note that order matters! Each input object will overwrite the properties of the previous objects.
+ *
+ * @category Object : Merge
+ * @category Package : @augment-vir/common
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
  */
 export function mergeDeep(...inputs) {
-    if (!isLengthAtLeast(inputs, 1)) {
+    if (!check.isLengthAtLeast(inputs, 1)) {
         // nothing to merge if no inputs
         return {};
     }
@@ -18,12 +21,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 +37,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,19 @@
+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.
+ *
+ * @category Object : Merge
+ * @category Package : @augment-vir/common
+ * @example
+ *
+ * ```ts
+ * import {mergeDefinedProperties} from '@augment-vir/common';
+ *
+ * mergeDefinedProperties({a: 'default', b: 'default'}, {a: 'override', b: undefined});
+ * // output is `{a: 'override', b: 'default'}`
+ * ```
+ *
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+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,32 @@
+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.
+ *
+ * @category Object : Merge
+ * @category Package : @augment-vir/common
+ * @example
+ *
+ * ```ts
+ * import {mergeDefinedProperties} from '@augment-vir/common';
+ *
+ * mergeDefinedProperties({a: 'default', b: 'default'}, {a: 'override', b: undefined});
+ * // output is `{a: 'override', b: 'default'}`
+ * ```
+ *
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+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/augments/object/merge-property-arrays.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Merges all arrays by their property in the given objects.
+ *
+ * @category Object : Merge
+ * @category Package : @augment-vir/common
+ * @example
+ *
+ * ```ts
+ * import {mergePropertyArrays} from '@augment-vir/common';
+ *
+ * mergePropertyArrays(
+ *     {
+ *         a: [
+ *             'a',
+ *             'b',
+ *         ],
+ *     },
+ *     {
+ *         a: [
+ *             'c',
+ *             'd',
+ *         ],
+ *     },
+ * ); // output is `{a: ['a', 'b', 'c', 'd']}`
+ * ```
+ *
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export declare function mergePropertyArrays<T extends Record<PropertyKey, unknown[]>>(...inputs: ReadonlyArray<Readonly<T>>): T;

package/dist/augments/object/merge-property-arrays.js

@@ -0,0 +1,39 @@
+import { getOrSet } from './get-or-set.js';
+/**
+ * Merges all arrays by their property in the given objects.
+ *
+ * @category Object : Merge
+ * @category Package : @augment-vir/common
+ * @example
+ *
+ * ```ts
+ * import {mergePropertyArrays} from '@augment-vir/common';
+ *
+ * mergePropertyArrays(
+ *     {
+ *         a: [
+ *             'a',
+ *             'b',
+ *         ],
+ *     },
+ *     {
+ *         a: [
+ *             'c',
+ *             'd',
+ *         ],
+ *     },
+ * ); // output is `{a: ['a', 'b', 'c', 'd']}`
+ * ```
+ *
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export function mergePropertyArrays(...inputs) {
+    const combined = {};
+    inputs.forEach((input) => {
+        Object.entries(input).forEach(([key, newArray,]) => {
+            const currentArray = getOrSet(combined, key, () => []);
+            currentArray.push(...newArray);
+        });
+    });
+    return combined;
+}

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

@@ -0,0 +1,31 @@
+import { CompleteRequire } from '@augment-vir/core';
+/**
+ * Gets an object's entries. This is the same as
+ * [`Object.entries`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object/entries)
+ * except that it has better TypeScript types.
+ *
+ * @category Object
+ * @category Package : @augment-vir/common
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export declare function getObjectTypedEntries<const ObjectGeneric>(input: ObjectGeneric): [keyof ObjectGeneric, CompleteRequire<ObjectGeneric>[keyof CompleteRequire<ObjectGeneric>]][];
+/**
+ * Create an object from an array of entries. This is the same as
+ * [`Object.fromEntries`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object/fromEntries)
+ * except that it has better TypeScript types.
+ *
+ * @category Object
+ * @category Package : @augment-vir/common
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export declare function typedObjectFromEntries<const KeyType extends PropertyKey, const ValueType>(entries: ReadonlyArray<Readonly<[KeyType, ValueType]>>): Record<KeyType, ValueType>;
+/**
+ * Gets an object's entries and sorts them by their key values. This is the same as
+ * [`Object.entries`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object/entries)
+ * except that it has better TypeScript types and sorts the entries.
+ *
+ * @category Object
+ * @category Package : @augment-vir/common
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+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,40 @@
+import { getObjectTypedKeys } from '@augment-vir/core';
+/**
+ * Gets an object's entries. This is the same as
+ * [`Object.entries`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object/entries)
+ * except that it has better TypeScript types.
+ *
+ * @category Object
+ * @category Package : @augment-vir/common
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export function getObjectTypedEntries(input) {
+    return getObjectTypedKeys(input).map((key) => [
+        key,
+        input[key],
+    ]);
+}
+/**
+ * Create an object from an array of entries. This is the same as
+ * [`Object.fromEntries`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object/fromEntries)
+ * except that it has better TypeScript types.
+ *
+ * @category Object
+ * @category Package : @augment-vir/common
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export function typedObjectFromEntries(entries) {
+    return Object.fromEntries(entries);
+}
+/**
+ * Gets an object's entries and sorts them by their key values. This is the same as
+ * [`Object.entries`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object/entries)
+ * except that it has better TypeScript types and sorts the entries.
+ *
+ * @category Object
+ * @category Package : @augment-vir/common
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+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,22 @@
+import { type Values } from '@augment-vir/core';
+/**
+ * Filters an object. Like
+ * [`[].filter`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object/fromEntries)
+ * but for objects.
+ *
+ * @category Object
+ * @category Package : @augment-vir/common
+ * @example
+ *
+ * ```ts
+ * import {filterObject} from '@augment-vir';
+ *
+ * filterObject({a: 1, b: 2, c: 3}, (key, value) => {
+ *     return value >= 2;
+ * });
+ * // output is `{b: 2, c: 3}`
+ * ```
+ *
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export declare function filterObject<ObjectGeneric>(inputObject: ObjectGeneric, callback: (key: keyof ObjectGeneric, value: Values<ObjectGeneric>, fullObject: ObjectGeneric) => boolean): Partial<ObjectGeneric>;