@oscarpalmer/atoms 0.166.1 → 0.166.3

package/dist/models.d.mts

@@ -41,7 +41,7 @@ type GenericCallback = (...args: any[]) => any;
  * A generic key type
  */
 type Key = number | string;
-type KeyedValue<Item, Key extends keyof Item> = Item[Key] extends PropertyKey ? Item[Key] : never;
+type KeyedValue<Item, ItemKey extends keyof Item> = Item[ItemKey] extends PropertyKey ? Item[ItemKey] : never;
 /**
  * A nested array
  */
@@ -50,16 +50,16 @@ type NestedArray<Value> = Value extends Array<infer NestedValue> ? NestedArray<N
  * All nested keys of an object as dot notation strings _(up to 5 levels deep)_
  */
 type NestedKeys<Value extends PlainObject> = _NestedKeys<Value>;
-type _NestedKeys<Value, Depth extends number = 5> = Depth extends 0 ? never : Value extends readonly any[] ? Value extends readonly [any, ...any] ? { [Key in keyof Value]-?: Key extends `${number}` ? NonNullable<Value[Key]> extends readonly any[] | PlainObject ? `${Key}` | `${Key}.${_NestedKeys<NonNullable<Value[Key]>, SubtractDepth<Depth>>}` : `${Key}` : never }[number] : never : Value extends PlainObject ? { [Key in keyof Value]-?: Key extends number | string ? NonNullable<Value[Key]> extends readonly any[] | PlainObject ? `${Key}` | `${Key}.${_NestedKeys<NonNullable<Value[Key]>, SubtractDepth<Depth>>}` : `${Key}` : never }[keyof Value] : never;
+type _NestedKeys<Value, Depth extends number = 5> = Depth extends 0 ? never : Value extends readonly any[] ? Value extends readonly [any, ...any] ? { [ItemKey in keyof Value]-?: ItemKey extends `${number}` ? NonNullable<Value[ItemKey]> extends readonly any[] | PlainObject ? `${ItemKey}` | `${ItemKey}.${_NestedKeys<NonNullable<Value[ItemKey]>, SubtractDepth<Depth>>}` : `${ItemKey}` : never }[number] : never : Value extends PlainObject ? { [ItemKey in keyof Value]-?: ItemKey extends number | string ? NonNullable<Value[ItemKey]> extends readonly any[] | PlainObject ? `${ItemKey}` | `${ItemKey}.${_NestedKeys<NonNullable<Value[ItemKey]>, SubtractDepth<Depth>>}` : `${ItemKey}` : never }[keyof Value] : never;
 /**
  * An extended version of `Partial` that allows for nested properties to be optional
  */
-type NestedPartial<Value> = { [Key in keyof Value]?: Value[Key] extends object ? NestedPartial<Value[Key]> : Value[Key] };
+type NestedPartial<Value> = { [ItemKey in keyof Value]?: Value[ItemKey] extends object ? NestedPartial<Value[ItemKey]> : Value[ItemKey] };
 /**
  * The value for a nested key of an object
  */
 type NestedValue<Value extends PlainObject, Path extends string> = _NestedValue<Value, Path>;
-type _NestedValue<Value, Path extends string> = Path extends `${infer Key}.${infer Rest}` ? Key extends keyof Value ? undefined extends Value[Key] ? _NestedValue<Exclude<Value[Key], undefined>, Rest> | undefined : _NestedValue<Value[Key], Rest> : Key extends `${number}` ? Value extends readonly any[] ? _NestedValue<Value[number], Rest> : never : never : Path extends `${number}` ? Value extends readonly any[] ? Value[number] : never : Path extends keyof Value ? Value[Path] : never;
+type _NestedValue<Value, Path extends string> = Path extends `${infer ItemKey}.${infer Rest}` ? ItemKey extends keyof Value ? undefined extends Value[ItemKey] ? _NestedValue<Exclude<Value[ItemKey], undefined>, Rest> | undefined : _NestedValue<Value[ItemKey], Rest> : ItemKey extends `${number}` ? Value extends readonly any[] ? _NestedValue<Value[number], Rest> : never : never : Path extends `${number}` ? Value extends readonly any[] ? Value[number] : never : Path extends keyof Value ? Value[Path] : never;
 /**
  * The nested (keyed) values of an object _(up to 5 levels deep)_
  */
@@ -67,11 +67,11 @@ type NestedValues<Value extends PlainObject> = { [Path in NestedKeys<Value>]: Ne
 /**
  * The numerical keys of an object
  */
-type NumericalKeys<Value> = { [Key in keyof Value]: Key extends number ? Key : Key extends `${number}` ? Key : never }[keyof Value];
+type NumericalKeys<Value> = { [ItemKey in keyof Value]: ItemKey extends number ? ItemKey : ItemKey extends `${number}` ? ItemKey : never }[keyof Value];
 /**
  * The numerical values of an object
  */
-type NumericalValues<Item extends PlainObject> = { [Key in keyof Item as Item[Key] extends number ? Key : never]: Item[Key] };
+type NumericalValues<Item extends PlainObject> = { [ItemKey in keyof Item as Item[ItemKey] extends number ? ItemKey : never]: Item[ItemKey] };
 /**
  * An asynchronous function that can only be called once, returning the same value on subsequent calls
  */
@@ -122,7 +122,7 @@ type RequiredKeys<Model extends object, Keys extends keyof Model> = Required<Pic
  *
  * _(Thanks, type-fest!)_
  */
-type Simplify<Value> = { [Key in keyof Value]: Value[Key] } & {};
+type Simplify<Value> = { [ValueKey in keyof Value]: Value[ValueKey] } & {};
 type SubtractDepth<Value extends number> = Value extends 5 ? 4 : Value extends 4 ? 3 : Value extends 3 ? 2 : Value extends 2 ? 1 : Value extends 1 ? 0 : never;
 /**
  * Get the value's type as a string

package/dist/promise/models.d.mts

@@ -54,15 +54,15 @@ type PromiseStrategy = 'complete' | 'first';
 declare class PromiseTimeoutError extends Error {
   constructor();
 }
-type PromisesItems<Items extends unknown[]> = { [Key in keyof Items]: Items[Key] extends GenericCallback ? ReturnType<Items[Key]> extends Promise<infer Value> ? Promise<Value> : never : Items[Key] extends Promise<infer Value> ? Promise<Value> : Promise<Items[Key]> };
+type PromisesItems<Items extends unknown[]> = { [ItemsKey in keyof Items]: Items[ItemsKey] extends GenericCallback ? ReturnType<Items[ItemsKey]> extends Promise<infer Value> ? Promise<Value> : never : Items[ItemsKey] extends Promise<infer Value> ? Promise<Value> : Promise<Items[ItemsKey]> };
 type PromisesOptions = {
   signal?: AbortSignal;
   strategy?: PromiseStrategy;
 };
-type PromisesResult<Items extends unknown[]> = { [Key in keyof Items]: Items[Key] extends Promise<infer Value> ? Result<Awaited<Value>> : never };
-type PromisesUnwrapped<Items extends unknown[]> = { [Key in keyof Items]: Items[Key] extends GenericCallback ? ReturnType<Items[Key]> extends Promise<infer Value> ? Awaited<Value> : never : Items[Key] extends Promise<infer Value> ? Awaited<Value> : never };
+type PromisesResult<Items extends unknown[]> = { [ItemsKey in keyof Items]: Items[ItemsKey] extends Promise<infer Value> ? Result<Awaited<Value>> : never };
+type PromisesUnwrapped<Items extends unknown[]> = { [ItemsKey in keyof Items]: Items[ItemsKey] extends GenericCallback ? ReturnType<Items[ItemsKey]> extends Promise<infer Value> ? Awaited<Value> : never : Items[ItemsKey] extends Promise<infer Value> ? Awaited<Value> : never };
 type PromisesValue<Value> = FulfilledPromise<Value> | RejectedPromise;
-type PromisesValues<Items extends unknown[]> = { [Key in keyof Items]: Items[Key] extends GenericCallback ? ReturnType<Items[Key]> extends Promise<infer Value> ? PromisesValue<Awaited<Value>> : never : Items[Key] extends Promise<infer Value> ? PromisesValue<Awaited<Value>> : never };
+type PromisesValues<Items extends unknown[]> = { [ItemsKey in keyof Items]: Items[ItemsKey] extends GenericCallback ? ReturnType<Items[ItemsKey]> extends Promise<infer Value> ? PromisesValue<Awaited<Value>> : never : Items[ItemsKey] extends Promise<infer Value> ? PromisesValue<Awaited<Value>> : never };
 type RejectedPromise = {
   status: typeof PROMISE_TYPE_REJECTED;
   reason: unknown;

package/dist/sized/map.d.mts

@@ -4,7 +4,7 @@
  *
  * Behavior is similar to a _LRU_-cache, where the least recently used entries are removed
  */
-declare class SizedMap<Key = unknown, Value = unknown> extends Map<Key, Value> {
+declare class SizedMap<SizedKey = unknown, SizedValue = unknown> extends Map<SizedKey, SizedValue> {
   #private;
   /**
    * Is the Map full?
@@ -14,33 +14,33 @@ declare class SizedMap<Key = unknown, Value = unknown> extends Map<Key, Value> {
   /**
    * Create a new SizedMap with entries and a maximum size _(2^20)_
    * @param entries Array of key-value pairs to initialize the SizedMap with
-   * @template Key Type of the keys in the SizedMap
-   * @template Value Type of the values in the SizedMap
+   * @template SizedKey Type of the keys in the SizedMap
+   * @template SizedValue Type of the values in the SizedMap
    */
-  constructor(entries: [Key, Value][]);
+  constructor(entries: [SizedKey, SizedValue][]);
   /**
    * Create a new SizedMap with a maximum size _(but clamped at 2^24)_
    * @param maximum Maximum size of the SizedMap
-   * @template Key Type of the keys in the SizedMap
-   * @template Value Type of the values in the SizedMap
+   * @template SizedKey Type of the keys in the SizedMap
+   * @template SizedValue Type of the values in the SizedMap
    */
   constructor(maximum: number);
   /**
    * Create a new SizedMap with _(optional)_ entries and a maximum size _(defaults to 2^20; clamped at 2^24)_
    * @param entries Array of key-value pairs to initialize the SizedMap with
    * @param maximum Maximum size of the SizedMap
-   * @template Key Type of the keys in the SizedMap
-   * @template Value Type of the values in the SizedMap
+   * @template SizedKey Type of the keys in the SizedMap
+   * @template SizedValue Type of the values in the SizedMap
    */
-  constructor(entries?: [Key, Value][], maximum?: number);
+  constructor(entries?: [SizedKey, SizedValue][], maximum?: number);
   /**
    * @inheritdoc
    */
-  get(key: Key): Value | undefined;
+  get(key: SizedKey): SizedValue | undefined;
   /**
    * @inheritdoc
    */
-  set(key: Key, value: Value): this;
+  set(key: SizedKey, value: SizedValue): this;
 }
 //#endregion
 export { SizedMap };

package/dist/value/omit.d.mts

@@ -7,6 +7,6 @@ import { PlainObject } from "../models.mjs";
  * @param keys Keys to omit
  * @returns Partial object without the specified keys
  */
-declare function omit<Value extends PlainObject, Key extends keyof Value>(value: Value, keys: Key[]): Omit<Value, Key>;
+declare function omit<Value extends PlainObject, ValueKey extends keyof Value>(value: Value, keys: ValueKey[]): Omit<Value, ValueKey>;
 //#endregion
 export { omit };

package/dist/value/pick.d.mts

@@ -7,6 +7,6 @@ import { PlainObject } from "../models.mjs";
  * @param keys Keys to use
  * @returns Partial object with only the specified keys
  */
-declare function pick<Value extends PlainObject, Key extends keyof Value>(value: Value, keys: Key[]): Pick<Value, Key>;
+declare function pick<Value extends PlainObject, ValueKey extends keyof Value>(value: Value, keys: ValueKey[]): Pick<Value, ValueKey>;
 //#endregion
 export { pick };

package/dist/value/smush.d.mts

@@ -1,7 +1,7 @@
 import { NestedKeys, NestedValue, PlainObject, Simplify, ToString } from "../models.mjs";
 
 //#region src/value/smush.d.ts
-type Smushed<Value extends PlainObject> = Simplify<{ [Key in NestedKeys<Value>]: NestedValue<Value, ToString<Key>> }>;
+type Smushed<Value extends PlainObject> = Simplify<{ [NestedKey in NestedKeys<Value>]: NestedValue<Value, ToString<NestedKey>> }>;
 /**
  * Smush an object into a flat object that uses dot notation keys
  * @param value Object to smush

package/dist/value/unsmush.d.mts

@@ -9,7 +9,7 @@ type KeysOfUnion<ObjectType> = keyof UnionToIntersection<ObjectType extends unkn
  * Thanks, type-fest!
  */
 type UnionToIntersection<Union> = (Union extends unknown ? (distributedUnion: Union) => void : never) extends ((mergedIntersection: infer Intersection) => void) ? Intersection & Union : never;
-type Unsmushed<Value extends PlainObject> = Simplify<Omit<{ [Key in KeysOfUnion<Value>]: Value[Key] }, `${string}.${string}`>>;
+type Unsmushed<Value extends PlainObject> = Simplify<Omit<{ [UnionKey in KeysOfUnion<Value>]: Value[UnionKey] }, `${string}.${string}`>>;
 /**
  * Unsmush a smushed object _(turning dot notation keys into nested keys)_
  * @param value Object to unsmush

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oscarpalmer/atoms",
-	"version": "0.166.1",
+	"version": "0.166.3",
 	"description": "Atomic utilities for making your JavaScript better.",
 	"keywords": [
 		"helper",

package/src/array/difference.ts

@@ -24,8 +24,8 @@ export function difference<First, Second>(
 export function difference<
 	First extends PlainObject,
 	Second extends PlainObject,
-	Key extends keyof First & keyof Second,
->(first: First[], second: Second[], key: Key): First[];
+	SharedKey extends keyof First & keyof Second,
+>(first: First[], second: Second[], key: SharedKey): First[];
 
 /**
  * Get the items from the first array that are not in the second array

package/src/array/exists.ts

@@ -22,10 +22,10 @@ export function exists<
  * @param value Value to match against
  * @returns `true` if the item exists in the array, otherwise `false`
  */
-export function exists<Item extends PlainObject, Key extends keyof Item>(
+export function exists<Item extends PlainObject, ItemKey extends keyof Item>(
 	array: Item[],
-	key: Key,
-	value: Item[Key],
+	key: ItemKey,
+	value: Item[ItemKey],
 ): boolean;
 
 /**

package/src/array/filter.ts

@@ -22,10 +22,10 @@ export function filter<
  * @param value Value to match against
  * @returns Filtered array of items
  */
-export function filter<Item extends PlainObject, Key extends keyof Item>(
+export function filter<Item extends PlainObject, ItemKey extends keyof Item>(
 	array: Item[],
-	key: Key,
-	value: Item[Key],
+	key: ItemKey,
+	value: Item[ItemKey],
 ): Item[];
 
 /**
@@ -58,10 +58,10 @@ function removeFiltered<
 	Callback extends (item: Item, index: number, array: Item[]) => unknown,
 >(array: Item[], callback: Callback, value: ReturnType<Callback>): unknown[];
 
-function removeFiltered<Item extends PlainObject, Key extends keyof Item>(
+function removeFiltered<Item extends PlainObject, ItemKey extends keyof Item>(
 	array: Item[],
-	key: Key,
-	value: Item[Key],
+	key: ItemKey,
+	value: Item[ItemKey],
 ): unknown[];
 
 function removeFiltered<Item>(

package/src/array/find.ts

@@ -23,10 +23,10 @@ export function find<Item, Callback extends (item: Item, index: number, array: I
  * @param value Value to match against
  * @returns First item that matches the value, or `undefined` if no match is found
  */
-export function find<Item extends PlainObject, Key extends keyof Item>(
+export function find<Item extends PlainObject, ItemKey extends keyof Item>(
 	array: Item[],
-	key: Key,
-	value: Item[Key],
+	key: ItemKey,
+	value: Item[ItemKey],
 ): Item | undefined;
 
 /**

package/src/array/intersection.ts

@@ -23,8 +23,8 @@ export function intersection<First, Second>(
 export function intersection<
 	First extends Record<string, unknown>,
 	Second extends Record<string, unknown>,
-	Key extends keyof First & keyof Second,
->(first: First[], second: Second[], key: Key): First[];
+	SharedKey extends keyof First & keyof Second,
+>(first: First[], second: Second[], key: SharedKey): First[];
 
 /**
  * Get the common values between two arrays

package/src/array/move.ts

@@ -14,11 +14,11 @@ import {indexOfArray} from './position';
  * @param key Key to get an item's value for matching
  * @returns Original array with items moved _(or unchanged if unable to move)_
  */
-export function move<Item extends PlainObject, Key extends keyof Item>(
+export function move<Item extends PlainObject, ItemKey extends keyof Item>(
 	array: Item[],
 	from: Item | Item[],
 	to: Item | Item[],
-	key: Key,
+	key: ItemKey,
 ): Item[];
 
 /**
@@ -156,11 +156,11 @@ function moveIndices<Item>(array: Item[], from: number, to: number): Item[] {
  * @param key Key to get an item's value for matching
  * @returns Original array with items moved _(or unchanged if unable to move)_
  */
-function moveToIndex<Item extends PlainObject, Key extends keyof Item>(
+function moveToIndex<Item extends PlainObject, ItemKey extends keyof Item>(
 	array: Item[],
 	value: Item | Item[],
 	index: number,
-	key: Key,
+	key: ItemKey,
 ): Item[];
 
 /**

package/src/array/partition.ts

@@ -22,10 +22,10 @@ export function partition<
  * @param value Value to match against
  * @returns Partitioned array of items
  */
-export function partition<Item extends PlainObject, Key extends keyof Item>(
+export function partition<Item extends PlainObject, ItemKey extends keyof Item>(
 	array: Item[],
-	key: Key,
-	value: Item[Key],
+	key: ItemKey,
+	value: Item[ItemKey],
 ): Item[][];
 
 /**

package/src/array/select.ts

@@ -30,12 +30,12 @@ export function select<
  */
 export function select<
 	Item extends PlainObject,
-	Key extends keyof Item,
+	ItemKey extends keyof Item,
 	MapCallback extends (item: Item, index: number, array: Item[]) => unknown,
 >(
 	array: Item[],
-	filterKey: Key,
-	filterValue: Item[Key],
+	filterKey: ItemKey,
+	filterValue: Item[ItemKey],
 	mapCallback: MapCallback,
 ): Array<ReturnType<MapCallback>>;
 

package/src/array/slice.ts

@@ -16,10 +16,10 @@ type ExtractType = 'drop' | 'take';
  * @param value Value to match against
  * @returns New array with items dropped
  */
-export function drop<Item extends PlainObject, Key extends keyof Item>(
+export function drop<Item extends PlainObject, ItemKey extends keyof Item>(
 	array: Item[],
-	key: Key,
-	value: Item[Key],
+	key: ItemKey,
+	value: Item[ItemKey],
 ): Item[];
 
 /**
@@ -192,10 +192,10 @@ export function slice(array: unknown[], first?: number, second?: number): unknow
  * @param value Value to match against
  * @returns New array with taken items
  */
-export function take<Item extends PlainObject, Key extends keyof Item>(
+export function take<Item extends PlainObject, ItemKey extends keyof Item>(
 	array: Item[],
-	key: Key,
-	value: Item[Key],
+	key: ItemKey,
+	value: Item[ItemKey],
 ): Item[];
 
 /**

package/src/array/sort.ts

@@ -21,11 +21,11 @@ export type ArrayComparisonSorter<Item> = {
 /**
  * Sorting information for arrays _(using a key)_
  */
-export type ArrayKeySorter<Item extends PlainObject, Key extends keyof Item> = {
+export type ArrayKeySorter<Item extends PlainObject, ItemKey extends keyof Item> = {
 	/**
 	 * Comparator to use when comparing items and values
 	 */
-	compare?: CompareCallback<Item, Item[Key]>;
+	compare?: CompareCallback<Item, Item[ItemKey]>;
 	/**
 	 * Direction to sort by
 	 */
@@ -33,14 +33,14 @@ export type ArrayKeySorter<Item extends PlainObject, Key extends keyof Item> = {
 	/**
 	 * Key to sort by
 	 */
-	key: Key;
+	key: ItemKey;
 };
 
 /**
  * Sorters based on keys in an object
  */
 type ArrayKeySorters<Item extends PlainObject> = {
-	[Key in keyof Item]: ArrayKeySorter<Item, Key>;
+	[ItemKey in keyof Item]: ArrayKeySorter<Item, ItemKey>;
 }[keyof Item];
 
 /**

package/src/array/swap.ts

@@ -14,11 +14,11 @@ import {indexOfArray} from './position';
  * @param key Key to get an item's value for matching
  * @returns Original array with items swapped _(or unchanged if unable to swap)_
  */
-export function swap<Item extends PlainObject, Key extends keyof Item>(
+export function swap<Item extends PlainObject, ItemKey extends keyof Item>(
 	array: Item[],
 	first: Item[],
 	second: Item[],
-	key: Key,
+	key: ItemKey,
 ): Item[];
 
 /**
@@ -59,11 +59,11 @@ export function swap<Item>(array: Item[], first: Item[], second: Item[]): Item[]
  * @param key Key to get an item's value for matching
  * @returns Original array with items swapped _(or unchanged if unable to swap)_
  */
-export function swap<Item extends PlainObject, Key extends keyof Item>(
+export function swap<Item extends PlainObject, ItemKey extends keyof Item>(
 	array: Item[],
 	first: Item,
 	second: Item,
-	key: Key,
+	key: ItemKey,
 ): Item[];
 
 /**

package/src/array/to-set.ts

@@ -20,10 +20,10 @@ export function toSet<Item, Callback extends (item: Item, index: number, array:
  * @param key Key to use for value
  * @returns Set of values
  */
-export function toSet<Item extends PlainObject, Key extends keyof Item>(
+export function toSet<Item extends PlainObject, ItemKey extends keyof Item>(
 	array: Item[],
-	key: Key,
-): Set<Item[Key]>;
+	key: ItemKey,
+): Set<Item[ItemKey]>;
 
 /**
  * Create a Set from an array of items

package/src/array/toggle.ts

@@ -21,10 +21,10 @@ export function toggle<Item>(
  * @param key Key to find existing item
  * @returns Original array
  */
-export function toggle<Item extends PlainObject, Key extends keyof Item>(
+export function toggle<Item extends PlainObject, ItemKey extends keyof Item>(
 	destination: Item[],
 	toggled: Item[],
-	key: Key,
+	key: ItemKey,
 ): Item[];
 
 /**

package/src/array/union.ts

@@ -23,8 +23,8 @@ export function union<First, Second>(
 export function union<
 	First extends Record<string, unknown>,
 	Second extends Record<string, unknown>,
-	Key extends keyof First & keyof Second,
->(first: First[], second: Second[], key: Key): (First | Second)[];
+	SharedKey extends keyof First & keyof Second,
+>(first: First[], second: Second[], key: SharedKey): (First | Second)[];
 
 /**
  * Get the combined, unique values from two arrays

package/src/array/update.ts

@@ -21,10 +21,10 @@ export function update<Item>(
  * @param key Key to find existing item
  * @returns Original array
  */
-export function update<Item extends PlainObject, Key extends keyof Item>(
+export function update<Item extends PlainObject, ItemKey extends keyof Item>(
 	destination: Item[],
 	updated: Item[],
-	key: Key,
+	key: ItemKey,
 ): Item[];
 
 /**

package/src/internal/array/index-of.ts

@@ -22,10 +22,10 @@ export function indexOf<
  * @param value Value to match against
  * @returns Index of the first matching item, or `-1` if no match is found
  */
-export function indexOf<Item extends PlainObject, Key extends keyof Item>(
+export function indexOf<Item extends PlainObject, ItemKey extends keyof Item>(
 	array: Item[],
-	key: Key,
-	value: Item[Key],
+	key: ItemKey,
+	value: Item[ItemKey],
 ): number;
 
 /**

package/src/internal/function/timer.ts

@@ -23,9 +23,7 @@ export function getTimer<Callback extends GenericCallback>(
 		start ??= now;
 
 		if (interval === 0 || now - start >= interval - OFFSET) {
-			if (throttle) {
-				start = now;
-			}
+			start = throttle ? now : undefined;
 
 			callback(...args);
 		} else {
@@ -37,7 +35,7 @@ export function getTimer<Callback extends GenericCallback>(
 
 	let args: Parameters<Callback>;
 	let frame: DOMHighResTimeStamp | undefined;
-	let start: DOMHighResTimeStamp;
+	let start: DOMHighResTimeStamp | undefined;
 
 	const timer = (...parameters: Parameters<Callback>): void => {
 		timer.cancel();

package/src/internal/math/aggregate.ts

@@ -81,9 +81,9 @@ export function max<Item>(
  * @param key Key to use for value
  * @returns Maximum value, or `NaN` if no maximum can be found
  */
-export function max<Item extends PlainObject, Key extends keyof NumericalValues<Item>>(
+export function max<Item extends PlainObject, ItemKey extends keyof NumericalValues<Item>>(
 	items: Item[],
-	key: Key,
+	key: ItemKey,
 ): number;
 
 /**

package/src/internal/value/partial.ts

@@ -1,20 +1,20 @@
 import type {PlainObject} from '../../models';
 
-export function partial<Value extends object, Key extends keyof Value>(
+export function partial<Value extends object, ValueKey extends keyof Value>(
 	value: unknown,
-	keys: Key[],
+	keys: ValueKey[],
 	omit: true,
-): Omit<Value, Key>;
+): Omit<Value, ValueKey>;
 
-export function partial<Value extends object, Key extends keyof Value>(
+export function partial<Value extends object, ValueKey extends keyof Value>(
 	value: unknown,
-	keys: Key[],
+	keys: ValueKey[],
 	omit: false,
-): Pick<Value, Key>;
+): Pick<Value, ValueKey>;
 
-export function partial<Value extends object, Key extends keyof Value>(
+export function partial<Value extends object, ValueKey extends keyof Value>(
 	value: unknown,
-	providedKeys: Key[],
+	providedKeys: ValueKey[],
 	omit: boolean,
 ): Partial<Value> {
 	if (typeof value !== 'object' || value === null) {
@@ -37,7 +37,7 @@ export function partial<Value extends object, Key extends keyof Value>(
 			continue;
 		}
 
-		if (omit ? !providedKeys.includes(key as Key) : true) {
+		if (omit ? !providedKeys.includes(key as ValueKey) : true) {
 			(partials as PlainObject)[key] = (value as PlainObject)[key];
 		}
 	}

package/src/math.ts

@@ -76,10 +76,10 @@ export function count<Item>(
  * @param value Value to match and count
  * @returns Number of items with the specified key value, or `NaN` if no count can be calculated
  */
-export function count<Item extends PlainObject, Key extends keyof Item>(
+export function count<Item extends PlainObject, ItemKey extends keyof Item>(
 	array: Item[],
-	key: Key,
-	value: Item[Key],
+	key: ItemKey,
+	value: Item[ItemKey],
 ): number;
 
 /**