@oscarpalmer/atoms 0.166.2 → 0.167.0

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/index.ts

@@ -38,10 +38,19 @@ export * from './logger';
 export * from './math';
 export * from './models';
 export * from './number';
+export * from './promise/delay';
 export * from './promise/index';
+export * from './promise/misc';
+export * from './promise/models';
+export * from './promise/timed';
 export * from './query';
 export * from './queue';
 export * from './random';
 export * from './result/index';
+export * from './result/match';
+export * from './result/misc';
+export * from './result/models';
+export * from './result/work/flow';
+export * from './result/work/pipe';
 export * from './sized/map';
 export * from './sized/set';

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/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;
 
 /**

package/src/models.ts

@@ -50,8 +50,8 @@ export type GenericCallback = (...args: any[]) => any;
  */
 export type Key = number | string;
 
-export type KeyedValue<Item, Key extends keyof Item> = Item[Key] extends PropertyKey
-	? Item[Key]
+export type KeyedValue<Item, ItemKey extends keyof Item> = Item[ItemKey] extends PropertyKey
+	? Item[ItemKey]
 	: never;
 
 /**
@@ -71,20 +71,24 @@ type _NestedKeys<Value, Depth extends number = 5> = Depth extends 0
 		? Value extends readonly [any, ...any]
 			? // Tuple: extract actual indices
 				{
-					[Key in keyof Value]-?: Key extends `${number}`
-						? NonNullable<Value[Key]> extends readonly any[] | PlainObject
-							? `${Key}` | `${Key}.${_NestedKeys<NonNullable<Value[Key]>, SubtractDepth<Depth>>}`
-							: `${Key}`
+					[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]
 			: // Array: use no indices
 				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}`
+					[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;
@@ -93,7 +97,9 @@ type _NestedKeys<Value, Depth extends number = 5> = Depth extends 0
  * An extended version of `Partial` that allows for nested properties to be optional
  */
 export type NestedPartial<Value> = {
-	[Key in keyof Value]?: Value[Key] extends object ? NestedPartial<Value[Key]> : Value[Key];
+	[ItemKey in keyof Value]?: Value[ItemKey] extends object
+		? NestedPartial<Value[ItemKey]>
+		: Value[ItemKey];
 };
 
 /**
@@ -101,12 +107,12 @@ export type NestedPartial<Value> = {
  */
 export 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}`
+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
@@ -130,14 +136,18 @@ export type NestedValues<Value extends PlainObject> = {
  * The numerical keys of an object
  */
 export type NumericalKeys<Value> = {
-	[Key in keyof Value]: Key extends number ? Key : Key extends `${number}` ? Key : never;
+	[ItemKey in keyof Value]: ItemKey extends number
+		? ItemKey
+		: ItemKey extends `${number}`
+			? ItemKey
+			: never;
 }[keyof Value];
 
 /**
  * The numerical values of an object
  */
 export type NumericalValues<Item extends PlainObject> = {
-	[Key in keyof Item as Item[Key] extends number ? Key : never]: Item[Key];
+	[ItemKey in keyof Item as Item[ItemKey] extends number ? ItemKey : never]: Item[ItemKey];
 };
 
 /**
@@ -200,7 +210,7 @@ export type RequiredKeys<Model extends object, Keys extends keyof Model> = Requi
  *
  * _(Thanks, type-fest!)_
  */
-export type Simplify<Value> = {[Key in keyof Value]: Value[Key]} & {};
+export type Simplify<Value> = {[ValueKey in keyof Value]: Value[ValueKey]} & {};
 
 type SubtractDepth<Value extends number> = Value extends 5
 	? 4

package/src/promise/index.ts

@@ -283,25 +283,3 @@ async function resultPromises(
 }
 
 // #endregion
-
-// #region Exports
-
-export {toPromise as fromResult} from '../result/misc';
-export {delay} from './delay';
-export {isFulfilled, isRejected} from './helpers';
-export {cancelable, toResult} from './misc';
-export {
-	CancelablePromise,
-	PromiseTimeoutError,
-	type FulfilledPromise,
-	type PromiseOptions,
-	type PromisesOptions,
-	type PromisesResult,
-	type PromiseStrategy,
-	type PromisesValues as PromisesValue,
-	type PromisesValue as PromisesValueItem,
-	type RejectedPromise,
-} from './models';
-export {timed} from './timed';
-
-// #endregion

package/src/promise/misc.ts

@@ -84,3 +84,10 @@ export async function toResult<Value>(
 }
 
 // #endregion
+
+// #region Exports
+
+export {toPromise as fromResult} from '../result/misc';
+export {isFulfilled, isRejected} from './helpers';
+
+// #endregion

package/src/promise/models.ts

@@ -84,13 +84,13 @@ export class PromiseTimeoutError extends Error {
 }
 
 export type PromisesItems<Items extends unknown[]> = {
-	[Key in keyof Items]: Items[Key] extends GenericCallback
-		? ReturnType<Items[Key]> extends Promise<infer Value>
+	[ItemsKey in keyof Items]: Items[ItemsKey] extends GenericCallback
+		? ReturnType<Items[ItemsKey]> extends Promise<infer Value>
 			? Promise<Value>
 			: never
-		: Items[Key] extends Promise<infer Value>
+		: Items[ItemsKey] extends Promise<infer Value>
 			? Promise<Value>
-			: Promise<Items[Key]>;
+			: Promise<Items[ItemsKey]>;
 };
 
 export type PromisesOptions = {
@@ -99,15 +99,17 @@ export type PromisesOptions = {
 };
 
 export type PromisesResult<Items extends unknown[]> = {
-	[Key in keyof Items]: Items[Key] extends Promise<infer Value> ? Result<Awaited<Value>> : never;
+	[ItemsKey in keyof Items]: Items[ItemsKey] extends Promise<infer Value>
+		? Result<Awaited<Value>>
+		: never;
 };
 
 export type PromisesUnwrapped<Items extends unknown[]> = {
-	[Key in keyof Items]: Items[Key] extends GenericCallback
-		? ReturnType<Items[Key]> extends Promise<infer Value>
+	[ItemsKey in keyof Items]: Items[ItemsKey] extends GenericCallback
+		? ReturnType<Items[ItemsKey]> extends Promise<infer Value>
 			? Awaited<Value>
 			: never
-		: Items[Key] extends Promise<infer Value>
+		: Items[ItemsKey] extends Promise<infer Value>
 			? Awaited<Value>
 			: never;
 };
@@ -115,11 +117,11 @@ export type PromisesUnwrapped<Items extends unknown[]> = {
 export type PromisesValue<Value> = FulfilledPromise<Value> | RejectedPromise;
 
 export type PromisesValues<Items extends unknown[]> = {
-	[Key in keyof Items]: Items[Key] extends GenericCallback
-		? ReturnType<Items[Key]> extends Promise<infer Value>
+	[ItemsKey in keyof Items]: Items[ItemsKey] extends GenericCallback
+		? ReturnType<Items[ItemsKey]> extends Promise<infer Value>
 			? PromisesValue<Awaited<Value>>
 			: never
-		: Items[Key] extends Promise<infer Value>
+		: Items[ItemsKey] extends Promise<infer Value>
 			? PromisesValue<Awaited<Value>>
 			: never;
 };

package/src/result/index.ts

@@ -95,12 +95,3 @@ attempt.pipe = attemptPipe;
 attempt.promise = attemptPromise;
 
 // #endregion
-
-// #region Exports
-
-export {isError, isOk, isResult} from '../internal/result';
-export {toResult as fromPromise} from '../promise/misc';
-export {error, ok, toPromise, unwrap} from './misc';
-export type {Err, ExtendedErr, ExtendedResult, Ok, Result} from './models';
-
-// #endregion

package/src/result/misc.ts

@@ -113,3 +113,9 @@ export function unwrap(value: unknown, defaultValue: unknown): unknown {
 const MESSAGE_PROMISE_RESULT = 'toPromise expected to receive a Result';
 
 // #endregion
+
+// #region Exports
+
+export {isError, isOk, isResult} from '../internal/result';
+
+// #endregion

package/src/sized/map.ts

@@ -7,7 +7,7 @@ import {getSizedMaximum} from '../internal/sized';
  *
  * Behavior is similar to a _LRU_-cache, where the least recently used entries are removed
  */
-export class SizedMap<Key = unknown, Value = unknown> extends Map<Key, Value> {
+export class SizedMap<SizedKey = unknown, SizedValue = unknown> extends Map<SizedKey, SizedValue> {
 	/**
 	 * The maximum size of the Map
 	 */
@@ -27,16 +27,16 @@ export 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);
 
@@ -44,12 +44,12 @@ export class SizedMap<Key = unknown, Value = unknown> extends Map<Key, Value> {
 	 * 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);
 
-	constructor(first?: [Key, Value][] | number, second?: number) {
+	constructor(first?: [SizedKey, SizedValue][] | number, second?: number) {
 		const maximum = getSizedMaximum(first, second);
 
 		super();
@@ -74,11 +74,11 @@ export class SizedMap<Key = unknown, Value = unknown> extends Map<Key, Value> {
 	/**
 	 * @inheritdoc
 	 */
-	override get(key: Key): Value | undefined {
+	override get(key: SizedKey): SizedValue | undefined {
 		const value = super.get(key);
 
 		if (value !== undefined || this.has(key)) {
-			this.set(key, value as Value);
+			this.set(key, value as SizedValue);
 		}
 
 		return value;
@@ -87,11 +87,11 @@ export class SizedMap<Key = unknown, Value = unknown> extends Map<Key, Value> {
 	/**
 	 * @inheritdoc
 	 */
-	override set(key: Key, value: Value): this {
+	override set(key: SizedKey, value: SizedValue): this {
 		if (this.has(key)) {
 			this.delete(key);
 		} else if (this.size >= this.#maximumSize) {
-			this.delete(this.keys().next().value as Key);
+			this.delete(this.keys().next().value as SizedKey);
 		}
 
 		return super.set(key, value);

package/src/value/omit.ts

@@ -9,10 +9,10 @@ import type {PlainObject} from '../models';
  * @param keys Keys to omit
  * @returns Partial object without the specified keys
  */
-export function omit<Value extends PlainObject, Key extends keyof Value>(
+export function omit<Value extends PlainObject, ValueKey extends keyof Value>(
 	value: Value,
-	keys: Key[],
-): Omit<Value, Key> {
+	keys: ValueKey[],
+): Omit<Value, ValueKey> {
 	return partial(value, keys, true);
 }
 

package/src/value/pick.ts

@@ -9,10 +9,10 @@ import type {PlainObject} from '../models';
  * @param keys Keys to use
  * @returns Partial object with only the specified keys
  */
-export function pick<Value extends PlainObject, Key extends keyof Value>(
+export function pick<Value extends PlainObject, ValueKey extends keyof Value>(
 	value: Value,
-	keys: Key[],
-): Pick<Value, Key> {
+	keys: ValueKey[],
+): Pick<Value, ValueKey> {
 	return partial(value, keys, false);
 }
 

package/src/value/smush.ts

@@ -12,7 +12,7 @@ import type {
 // #region Types
 
 export type Smushed<Value extends PlainObject> = Simplify<{
-	[Key in NestedKeys<Value>]: NestedValue<Value, ToString<Key>>;
+	[NestedKey in NestedKeys<Value>]: NestedValue<Value, ToString<NestedKey>>;
 }>;
 
 // #endregion

package/src/value/unsmush.ts

@@ -28,7 +28,7 @@ type UnionToIntersection<Union> = (
 export type Unsmushed<Value extends PlainObject> = Simplify<
 	Omit<
 		{
-			[Key in KeysOfUnion<Value>]: Value[Key];
+			[UnionKey in KeysOfUnion<Value>]: Value[UnionKey];
 		},
 		`${string}.${string}`
 	>