@oscarpalmer/atoms 0.165.2 → 0.166.1

package/dist/array/index.d.mts

@@ -15,10 +15,11 @@ import { ArrayPosition, endsWithArray, getArrayPosition, includesArray, indexOfA
 import { push } from "./push.mjs";
 import { select } from "./select.mjs";
 import { drop, slice, take } from "./slice.mjs";
-import { sort } from "./sort.mjs";
+import { ArrayComparisonSorter, ArrayKeySorter, ArrayValueSorter, SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, SortDirection, sort } from "./sort.mjs";
 import { splice } from "./splice.mjs";
 import { toSet } from "./to-set.mjs";
 import { toggle } from "./toggle.mjs";
 import { union } from "./union.mjs";
+import { unique } from "./unique.mjs";
 import { update } from "./update.mjs";
-export { ArrayPosition, chunk, compact, difference, drop, endsWithArray, exists, find, flatten, getArray, getArrayPosition, includesArray, indexOf, indexOfArray, insert, intersection, partition, push, range, select, shuffle, slice, sort, splice, startsWithArray, take, times, toSet, toggle, union, update };
+export { ArrayComparisonSorter, ArrayKeySorter, ArrayPosition, ArrayValueSorter, SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, SortDirection, chunk, compact, difference, drop, endsWithArray, exists, find, flatten, getArray, getArrayPosition, includesArray, indexOf, indexOfArray, insert, intersection, partition, push, range, select, shuffle, slice, sort, splice, startsWithArray, take, times, toSet, toggle, union, unique, update };

package/dist/array/index.mjs

@@ -15,10 +15,11 @@ import { endsWithArray, getArrayPosition, includesArray, indexOfArray, startsWit
 import { push } from "./push.mjs";
 import { select } from "./select.mjs";
 import { drop, slice, take } from "./slice.mjs";
-import { sort } from "./sort.mjs";
+import { SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, sort } from "./sort.mjs";
 import { splice } from "./splice.mjs";
 import { toSet } from "./to-set.mjs";
 import { toggle } from "./toggle.mjs";
 import { union } from "./union.mjs";
+import { unique } from "./unique.mjs";
 import { update } from "./update.mjs";
-export { chunk, compact, difference, drop, endsWithArray, exists, find, flatten, getArray, getArrayPosition, includesArray, indexOf, indexOfArray, insert, intersection, partition, push, range, select, shuffle, slice, sort, splice, startsWithArray, take, times, toSet, toggle, union, update };
+export { SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, chunk, compact, difference, drop, endsWithArray, exists, find, flatten, getArray, getArrayPosition, includesArray, indexOf, indexOfArray, insert, intersection, partition, push, range, select, shuffle, slice, sort, splice, startsWithArray, take, times, toSet, toggle, union, unique, update };

package/dist/array/sort.d.mts

@@ -2,30 +2,26 @@ import { PlainObject, Primitive } from "../models.mjs";
 
 //#region src/array/sort.d.ts
 /**
- * Sorting information for arrays _(using a callback)_
+ * Sorting information for arrays _(using a comparison callback)_
  */
-type ArrayCallbackSorter<Item> = {
+type ArrayComparisonSorter<Item> = {
   /**
-   * Comparator to use when comparing items and values
+   * Callback to use when comparing items and values
    */
-  compare?: (first: Item, firstValue: unknown, second: Item, secondValue: unknown) => number;
+  comparison: ComparisonSorter<Item>;
   /**
    * Direction to sort by
    */
   direction?: SortDirection;
-  /**
-   * Value to sort by
-   */
-  value: (item: Item) => unknown;
 };
 /**
  * Sorting information for arrays _(using a key)_
  */
-type ArrayKeySorter<Item> = {
+type ArrayKeySorter<Item extends PlainObject, Key extends keyof Item> = {
   /**
    * Comparator to use when comparing items and values
    */
-  compare?: (first: Item, firstValue: unknown, second: Item, secondValue: unknown) => number;
+  compare?: CompareCallback<Item, Item[Key]>;
   /**
    * Direction to sort by
    */
@@ -33,41 +29,42 @@ type ArrayKeySorter<Item> = {
   /**
    * Key to sort by
    */
-  key: keyof Item;
+  key: Key;
 };
-type SortDirection = 'ascending' | 'descending';
 /**
- * Sort an array of items, using multiple sorters to sort by specific values
- * @param array Array to sort
- * @param sorters Sorters to use for sorting
- * @param descending Sort in descending order? _(defaults to `false`; overridden by individual sorters)_
- * @returns Sorted array
+ * Sorters based on keys in an object
  */
-declare function sort<Item>(array: Item[], sorters: Array<((item: Item) => unknown) | ArrayCallbackSorter<Item>>, descending?: boolean): Item[];
+type ArrayKeySorters<Item extends PlainObject> = { [Key in keyof Item]: ArrayKeySorter<Item, Key> }[keyof Item];
 /**
- * Sort an array of items, using a sorter to sort by a specific value
- * @param array Array to sort
- * @param sorter Sorter to use for sorting
- * @param descending Sort in descending order? _(defaults to `false`; overridden by the sorter)_
- * @returns Sorted array
+ * Sorting information for arrays _(using a value callback and built-in comparison)_
+ */
+type ArrayValueSorter<Item> = {
+  /**
+   * Direction to sort by
+   */
+  direction?: SortDirection;
+  /**
+   * Value to sort by
+   */
+  value: (item: Item) => unknown;
+};
+/**
+ * Comparator to use when comparing items and values
  */
-declare function sort<Item>(array: Item[], sorter: ((item: Item) => unknown) | ArrayCallbackSorter<Item>, descending?: boolean): Item[];
+type CompareCallback<Item, Value = CompareCallbackValue<Item>> = (first: Item, firstValue: Value, second: Item, secondValue: Value) => number;
+type CompareCallbackValue<Item> = Item extends Primitive ? Item : unknown;
 /**
- * Sort an array of items, using multiple sorters to sort by specific values
- * @param array Array to sort
- * @param sorters Sorters to use for sorting
- * @param descending Sort in descending order? _(defaults to `false`; overridden by individual sorters)_
- * @returns Sorted array
+ * Callback to use when comparing items and values
  */
-declare function sort<Item extends PlainObject>(array: Item[], sorters: Array<keyof Item | ((item: Item) => unknown) | ArrayCallbackSorter<Item> | ArrayKeySorter<Item>>, descending?: boolean): Item[];
+type ComparisonSorter<Item> = (first: Item, second: Item) => number;
 /**
- * Sort an array of items, using a sorter to sort by a specific value
- * @param array Array to sort
- * @param sorter Sorter to use for sorting
- * @param descending Sort in descending order? _(defaults to `false`; overridden by the sorter)_
- * @returns Sorted array
+ * Direction to sort by
  */
-declare function sort<Item extends PlainObject>(array: Item[], sorter: keyof Item | ((item: Item) => unknown) | ArrayCallbackSorter<Item> | ArrayKeySorter<Item>, descending?: boolean): Item[];
+type SortDirection = 'ascending' | 'descending';
+/**
+ * Sorter to use for sorting
+ */
+type Sorter<Item> = Item extends PlainObject ? keyof Item | ArrayComparisonSorter<Item> | ArrayKeySorters<Item> | ArrayValueSorter<Item> | ComparisonSorter<Item> : ArrayComparisonSorter<Item> | ArrayValueSorter<Item> | ComparisonSorter<Item>;
 /**
  * Sort an array of items, using multiple sorters to sort by specific values
  * @param array Array to sort
@@ -75,15 +72,15 @@ declare function sort<Item extends PlainObject>(array: Item[], sorter: keyof Ite
  * @param descending Sort in descending order? _(defaults to `false`; overridden by individual sorters)_
  * @returns Sorted array
  */
-declare function sort<Item extends Primitive>(array: Item[], sorters: ((item: Item) => unknown)[], descending?: boolean): Item[];
+declare function sort<Item>(array: Item[], sorters: Array<Sorter<Item>>, descending?: boolean): Item[];
 /**
- * Sort an array of items, using a sorter to sort by a specific value
+ * Sort an array of items, using multiple sorters to sort by specific values
  * @param array Array to sort
  * @param sorter Sorter to use for sorting
- * @param descending Sort in descending order? _(defaults to `false`; overridden by the sorter)_
+ * @param descending Sort in descending order? _(defaults to `false`; overridden by individual sorters)_
  * @returns Sorted array
  */
-declare function sort<Item extends Primitive>(array: Item[], sorter: (item: Item) => unknown, descending?: boolean): Item[];
+declare function sort<Item>(array: Item[], sorter: Sorter<Item>, descending?: boolean): Item[];
 /**
  * Sort an array of items
  * @param array Array to sort
@@ -94,4 +91,4 @@ declare function sort<Item>(array: Item[], descending?: boolean): Item[];
 declare const SORT_DIRECTION_ASCENDING: SortDirection;
 declare const SORT_DIRECTION_DESCENDING: SortDirection;
 //#endregion
-export { ArrayCallbackSorter, ArrayKeySorter, SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, SortDirection, sort };
+export { ArrayComparisonSorter, ArrayKeySorter, ArrayValueSorter, SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, SortDirection, sort };

package/dist/array/sort.mjs

@@ -1,64 +1,71 @@
 import { isPlainObject } from "../internal/is.mjs";
 import { compare } from "../internal/value/compare.mjs";
 //#region src/array/sort.ts
-function getCallback(value, key, forObject) {
-	if (key != null) return;
-	if (forObject && typeof value.value === "function") return value.value;
-	return typeof value === "function" ? value : void 0;
-}
-function getKey(value, forObject) {
-	if (forObject && typeof value.key === "string") return value.key;
-	return typeof value === "string" ? value : void 0;
+function getComparisonSorter(callback, modifier) {
+	return {
+		modifier,
+		compare: { simple: callback },
+		get: false,
+		identifier: String(callback)
+	};
 }
-function getModifier(value, modifier, forObject) {
-	if (!forObject || typeof value.direction !== "string") return modifier;
-	if (value.direction === "ascending") return 1;
-	return value.direction === "descending" ? -1 : modifier;
+function getObjectSorter(obj, modifier) {
+	let sorter;
+	if (typeof obj.comparison === "function") sorter = getComparisonSorter(obj.comparison, modifier);
+	else if (typeof obj.key === "string") {
+		sorter = getValueSorter(obj.key, modifier);
+		if (typeof obj.compare === "function") sorter.compare = { complex: obj.compare };
+	} else if (typeof obj.value === "function") sorter = getValueSorter(obj.value, modifier);
+	if (sorter != null && typeof obj.direction === "string") sorter.modifier = modifiers[obj.direction] ?? modifier;
+	return sorter;
 }
 function getSorter(value, modifier) {
-	const forObject = isPlainObject(value);
-	const sorter = {
-		identifier: "",
-		modifier
-	};
-	sorter.compare = forObject && typeof value.compare === "function" ? value.compare : void 0;
-	sorter.key = getKey(value, forObject);
-	sorter.modifier = getModifier(value, modifier, forObject);
-	sorter.callback = getCallback(value, sorter.key, forObject);
-	if (sorter.key != null || sorter.callback != null) {
-		sorter.identifier = `${sorter.key ?? sorter.callback}`;
-		return sorter;
+	switch (true) {
+		case typeof value === "function": return getComparisonSorter(value, modifier);
+		case typeof value === "string": return getValueSorter(value, modifier);
+		case isPlainObject(value): return getObjectSorter(value, modifier);
+		default: break;
 	}
 }
+function getValueSorter(value, modifier) {
+	return {
+		modifier,
+		get: true,
+		identifier: String(value),
+		value: typeof value === "function" ? value : (item) => item[value]
+	};
+}
 function sort(array, first, second) {
 	if (!Array.isArray(array)) return [];
 	if (array.length < 2) return array;
-	const modifier = (first === true || second === true ? "descending" : "ascending") === "ascending" ? 1 : -1;
+	const modifier = modifiers[first === true || second === true ? SORT_DIRECTION_DESCENDING : SORT_DIRECTION_ASCENDING];
 	const sorters = (Array.isArray(first) ? first : [first]).map((item) => getSorter(item, modifier)).filter((sorter) => sorter != null).filter((current, index, filtered) => filtered.findIndex((next) => next.identifier === current.identifier) === index);
 	const { length } = sorters;
-	if (length === 0) return array.sort((firstItem, secondItem) => compare(firstItem, secondItem) * modifier);
+	if (length === 0) return array.sort((first, second) => compare(first, second) * modifier);
 	if (length === 1) {
 		const sorter = sorters[0];
-		const { callback, key } = sorter;
 		return array.sort((firstItem, secondItem) => {
-			const firstValue = key == null ? callback?.(firstItem) : firstItem[key];
-			const secondValue = key == null ? callback?.(secondItem) : secondItem[key];
-			return (sorter.compare?.(firstItem, firstValue, secondItem, secondValue) ?? compare(firstValue, secondValue)) * sorter.modifier;
+			const firstValue = sorter.get ? sorter.value(firstItem) : firstItem;
+			const secondValue = sorter.get ? sorter.value(secondItem) : secondItem;
+			return (sorter.compare?.complex?.(firstItem, firstValue, secondItem, secondValue) ?? sorter.compare?.simple?.(firstItem, secondItem) ?? compare(firstValue, secondValue)) * sorter.modifier;
 		});
 	}
 	return array.sort((firstItem, secondItem) => {
 		for (let index = 0; index < length; index += 1) {
 			const sorter = sorters[index];
-			const { callback, key } = sorter;
-			const firstValue = key == null ? callback?.(firstItem) : firstItem[key];
-			const secondValue = key == null ? callback?.(secondItem) : secondItem[key];
-			const compared = (sorter.compare?.(firstItem, firstValue, secondItem, secondValue) ?? compare(firstValue, secondValue)) * sorter.modifier;
-			if (compared !== 0) return compared;
+			const firstValue = sorter.value?.(firstItem) ?? firstItem;
+			const secondValue = sorter.value?.(secondItem) ?? secondItem;
+			const comparison = (sorter.compare?.complex?.(firstItem, firstValue, secondItem, secondValue) ?? sorter.compare?.simple?.(firstItem, secondItem) ?? compare(firstValue, secondValue)) * sorter.modifier;
+			if (comparison !== 0) return comparison;
 		}
 		return 0;
 	});
 }
 const SORT_DIRECTION_ASCENDING = "ascending";
 const SORT_DIRECTION_DESCENDING = "descending";
+const modifiers = {
+	[SORT_DIRECTION_ASCENDING]: 1,
+	[SORT_DIRECTION_DESCENDING]: -1
+};
 //#endregion
 export { SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, sort };

package/dist/index.d.mts

@@ -855,30 +855,26 @@ declare function take(array: unknown[], count: number): unknown[];
 //#endregion
 //#region src/array/sort.d.ts
 /**
- * Sorting information for arrays _(using a callback)_
+ * Sorting information for arrays _(using a comparison callback)_
  */
-type ArrayCallbackSorter<Item> = {
+type ArrayComparisonSorter<Item> = {
   /**
-   * Comparator to use when comparing items and values
+   * Callback to use when comparing items and values
    */
-  compare?: (first: Item, firstValue: unknown, second: Item, secondValue: unknown) => number;
+  comparison: ComparisonSorter<Item>;
   /**
    * Direction to sort by
    */
   direction?: SortDirection;
-  /**
-   * Value to sort by
-   */
-  value: (item: Item) => unknown;
 };
 /**
  * Sorting information for arrays _(using a key)_
  */
-type ArrayKeySorter<Item> = {
+type ArrayKeySorter<Item extends PlainObject, Key extends keyof Item> = {
   /**
    * Comparator to use when comparing items and values
    */
-  compare?: (first: Item, firstValue: unknown, second: Item, secondValue: unknown) => number;
+  compare?: CompareCallback<Item, Item[Key]>;
   /**
    * Direction to sort by
    */
@@ -886,41 +882,42 @@ type ArrayKeySorter<Item> = {
   /**
    * Key to sort by
    */
-  key: keyof Item;
+  key: Key;
 };
-type SortDirection = 'ascending' | 'descending';
 /**
- * Sort an array of items, using multiple sorters to sort by specific values
- * @param array Array to sort
- * @param sorters Sorters to use for sorting
- * @param descending Sort in descending order? _(defaults to `false`; overridden by individual sorters)_
- * @returns Sorted array
+ * Sorters based on keys in an object
  */
-declare function sort<Item>(array: Item[], sorters: Array<((item: Item) => unknown) | ArrayCallbackSorter<Item>>, descending?: boolean): Item[];
+type ArrayKeySorters<Item extends PlainObject> = { [Key in keyof Item]: ArrayKeySorter<Item, Key> }[keyof Item];
 /**
- * Sort an array of items, using a sorter to sort by a specific value
- * @param array Array to sort
- * @param sorter Sorter to use for sorting
- * @param descending Sort in descending order? _(defaults to `false`; overridden by the sorter)_
- * @returns Sorted array
+ * Sorting information for arrays _(using a value callback and built-in comparison)_
  */
-declare function sort<Item>(array: Item[], sorter: ((item: Item) => unknown) | ArrayCallbackSorter<Item>, descending?: boolean): Item[];
+type ArrayValueSorter<Item> = {
+  /**
+   * Direction to sort by
+   */
+  direction?: SortDirection;
+  /**
+   * Value to sort by
+   */
+  value: (item: Item) => unknown;
+};
 /**
- * Sort an array of items, using multiple sorters to sort by specific values
- * @param array Array to sort
- * @param sorters Sorters to use for sorting
- * @param descending Sort in descending order? _(defaults to `false`; overridden by individual sorters)_
- * @returns Sorted array
+ * Comparator to use when comparing items and values
  */
-declare function sort<Item extends PlainObject>(array: Item[], sorters: Array<keyof Item | ((item: Item) => unknown) | ArrayCallbackSorter<Item> | ArrayKeySorter<Item>>, descending?: boolean): Item[];
+type CompareCallback<Item, Value = CompareCallbackValue<Item>> = (first: Item, firstValue: Value, second: Item, secondValue: Value) => number;
+type CompareCallbackValue<Item> = Item extends Primitive ? Item : unknown;
 /**
- * Sort an array of items, using a sorter to sort by a specific value
- * @param array Array to sort
- * @param sorter Sorter to use for sorting
- * @param descending Sort in descending order? _(defaults to `false`; overridden by the sorter)_
- * @returns Sorted array
+ * Callback to use when comparing items and values
  */
-declare function sort<Item extends PlainObject>(array: Item[], sorter: keyof Item | ((item: Item) => unknown) | ArrayCallbackSorter<Item> | ArrayKeySorter<Item>, descending?: boolean): Item[];
+type ComparisonSorter<Item> = (first: Item, second: Item) => number;
+/**
+ * Direction to sort by
+ */
+type SortDirection = 'ascending' | 'descending';
+/**
+ * Sorter to use for sorting
+ */
+type Sorter<Item> = Item extends PlainObject ? keyof Item | ArrayComparisonSorter<Item> | ArrayKeySorters<Item> | ArrayValueSorter<Item> | ComparisonSorter<Item> : ArrayComparisonSorter<Item> | ArrayValueSorter<Item> | ComparisonSorter<Item>;
 /**
  * Sort an array of items, using multiple sorters to sort by specific values
  * @param array Array to sort
@@ -928,15 +925,15 @@ declare function sort<Item extends PlainObject>(array: Item[], sorter: keyof Ite
  * @param descending Sort in descending order? _(defaults to `false`; overridden by individual sorters)_
  * @returns Sorted array
  */
-declare function sort<Item extends Primitive>(array: Item[], sorters: ((item: Item) => unknown)[], descending?: boolean): Item[];
+declare function sort<Item>(array: Item[], sorters: Array<Sorter<Item>>, descending?: boolean): Item[];
 /**
- * Sort an array of items, using a sorter to sort by a specific value
+ * Sort an array of items, using multiple sorters to sort by specific values
  * @param array Array to sort
  * @param sorter Sorter to use for sorting
- * @param descending Sort in descending order? _(defaults to `false`; overridden by the sorter)_
+ * @param descending Sort in descending order? _(defaults to `false`; overridden by individual sorters)_
  * @returns Sorted array
  */
-declare function sort<Item extends Primitive>(array: Item[], sorter: (item: Item) => unknown, descending?: boolean): Item[];
+declare function sort<Item>(array: Item[], sorter: Sorter<Item>, descending?: boolean): Item[];
 /**
  * Sort an array of items
  * @param array Array to sort
@@ -944,6 +941,8 @@ declare function sort<Item extends Primitive>(array: Item[], sorter: (item: Item
  * @returns Sorted array
  */
 declare function sort<Item>(array: Item[], descending?: boolean): Item[];
+declare const SORT_DIRECTION_ASCENDING: SortDirection;
+declare const SORT_DIRECTION_DESCENDING: SortDirection;
 //#endregion
 //#region src/array/splice.d.ts
 /**
@@ -1051,6 +1050,28 @@ declare function union<First extends Record<string, unknown>, Second extends Rec
  */
 declare function union<First, Second>(first: First[], second: Second[]): (First | Second)[];
 //#endregion
+//#region src/array/unique.d.ts
+/**
+ * Get an array of unique items
+ * @param array Original array
+ * @param callback Callback to get an item's value
+ * @returns Array of unique items
+ */
+declare function unique<Item>(array: Item[], callback: (item: Item, index: number, array: Item[]) => unknown): Item[];
+/**
+ * Get an array of unique items
+ * @param array Original array
+ * @param key Key to use for unique value
+ * @returns Array of unique items
+ */
+declare function unique<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey): Item[];
+/**
+ * Get an array of unique items
+ * @param array Original array
+ * @returns Array of unique items
+ */
+declare function unique<Item>(array: Item[]): Item[];
+//#endregion
 //#region src/array/update.d.ts
 /**
  * Update an item in an array: if the item exists, it will be updated; if it doesn't, it will be added
@@ -1469,28 +1490,6 @@ declare function toRecordArrays<Item, Callback extends (item: Item, index: numbe
  */
 declare function toRecordArrays<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey): Simplify<Record<KeyedValue<Item, ItemKey>, Item[]>>;
 //#endregion
-//#region src/array/unique.d.ts
-/**
- * Get an array of unique items
- * @param array Original array
- * @param callback Callback to get an item's value
- * @returns Array of unique items
- */
-declare function unique<Item>(array: Item[], callback: (item: Item, index: number, array: Item[]) => unknown): Item[];
-/**
- * Get an array of unique items
- * @param array Original array
- * @param key Key to use for unique value
- * @returns Array of unique items
- */
-declare function unique<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey): Item[];
-/**
- * Get an array of unique items
- * @param array Original array
- * @returns Array of unique items
- */
-declare function unique<Item>(array: Item[]): Item[];
-//#endregion
 //#region src/function/assert.d.ts
 type Asserter<Value> = (value: unknown) => asserts value is Value;
 /**
@@ -4296,4 +4295,4 @@ declare class SizedSet<Value = unknown> extends Set<Value> {
   get(value: Value, update?: boolean): Value | undefined;
 }
 //#endregion
-export { ArrayOrPlainObject, ArrayPosition, Asserter, type Beacon, type BeaconOptions, BuiltIns, CancelableCallback, CancelablePromise, type Color, Constructor, DiffOptions, DiffResult, DiffValue, EqualOptions, type Err, EventPosition, type ExtendedErr, type ExtendedResult, Flow, FlowPromise, type FulfilledPromise, GenericAsyncCallback, GenericCallback, type HSLAColor, type HSLColor, HasValue, Key$1 as Key, KeyedValue, type Logger, type Memoized, type MemoizedOptions, MergeOptions, Merger, NestedArray, NestedKeys, NestedPartial, NestedValue, NestedValues, NumericalKeys, NumericalValues, type Observable, type Observer, type Ok, OnceAsyncCallback, OnceCallback, PlainObject, Primitive, type PromiseOptions, type PromiseStrategy, PromiseTimeoutError, type PromisesOptions, type PromisesResult, type PromisesValues as PromisesValue, type PromisesValue as PromisesValueItem, type Queue, QueueError, type QueueOptions, type Queued, type RGBAColor, type RGBColor, type RejectedPromise, RequiredKeys, type Result, RetryError, RetryOptions, Simplify, SizedMap, SizedSet, Smushed, type Subscription, TemplateOptions, type Time, ToString, TypedArray, Unsmushed, assert, attempt, attemptPromise, average, beacon, between, camelCase, cancelable, capitalize, ceil, chunk, clamp, clone, compact, compare, count, debounce, delay, diff, difference, drop, endsWith, endsWithArray, equal, error, exists, filter, find, flatten, floor, flow, toResult as fromPromise, toResult, fromQuery, toPromise as fromResult, toPromise, getArray, getArrayPosition, getColor, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getNormalizedHex, getNumber, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getString, getUuid, getValue, groupBy, hasValue, hexToHsl, hexToHsla, hexToRgb, hexToRgba, hslToHex, hslToRgb, hslToRgba, ignoreKey, includes, includesArray, indexOf, indexOfArray, insert, intersection, isArrayOrPlainObject, isColor, isConstructor, isEmpty, isError, isFulfilled, isHexColor, isHslColor, isHslLike, isHslaColor, isInstanceOf, isKey, isNonNullable, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isOk, isPlainObject, isPrimitive, isRejected, isResult, isRgbColor, isRgbLike, isRgbaColor, isTypedArray, join, kebabCase, logger, lowerCase, max, median, memoize, merge, min, move, noop, ok, omit, once, parse, partition, pascalCase, pick, pipe, promises, push, queue, range, retry, rgbToHex, rgbToHsl, rgbToHsla, round, select, setValue, shuffle, slice, smush, snakeCase, sort, splice, startsWith, startsWithArray, sum, swap, take, template, throttle, timed, times, titleCase, toMap, toQuery, toRecord, toSet, toggle, trim, truncate, tryDecode, tryEncode, union, unique, unsmush, unwrap, update, upperCase, words };
+export { ArrayComparisonSorter, ArrayKeySorter, ArrayOrPlainObject, ArrayPosition, ArrayValueSorter, Asserter, type Beacon, type BeaconOptions, BuiltIns, CancelableCallback, CancelablePromise, type Color, Constructor, DiffOptions, DiffResult, DiffValue, EqualOptions, type Err, EventPosition, type ExtendedErr, type ExtendedResult, Flow, FlowPromise, type FulfilledPromise, GenericAsyncCallback, GenericCallback, type HSLAColor, type HSLColor, HasValue, Key$1 as Key, KeyedValue, type Logger, type Memoized, type MemoizedOptions, MergeOptions, Merger, NestedArray, NestedKeys, NestedPartial, NestedValue, NestedValues, NumericalKeys, NumericalValues, type Observable, type Observer, type Ok, OnceAsyncCallback, OnceCallback, PlainObject, Primitive, type PromiseOptions, type PromiseStrategy, PromiseTimeoutError, type PromisesOptions, type PromisesResult, type PromisesValues as PromisesValue, type PromisesValue as PromisesValueItem, type Queue, QueueError, type QueueOptions, type Queued, type RGBAColor, type RGBColor, type RejectedPromise, RequiredKeys, type Result, RetryError, RetryOptions, SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, Simplify, SizedMap, SizedSet, Smushed, SortDirection, type Subscription, TemplateOptions, type Time, ToString, TypedArray, Unsmushed, assert, attempt, attemptPromise, average, beacon, between, camelCase, cancelable, capitalize, ceil, chunk, clamp, clone, compact, compare, count, debounce, delay, diff, difference, drop, endsWith, endsWithArray, equal, error, exists, filter, find, flatten, floor, flow, toResult as fromPromise, toResult, fromQuery, toPromise as fromResult, toPromise, getArray, getArrayPosition, getColor, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getNormalizedHex, getNumber, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getString, getUuid, getValue, groupBy, hasValue, hexToHsl, hexToHsla, hexToRgb, hexToRgba, hslToHex, hslToRgb, hslToRgba, ignoreKey, includes, includesArray, indexOf, indexOfArray, insert, intersection, isArrayOrPlainObject, isColor, isConstructor, isEmpty, isError, isFulfilled, isHexColor, isHslColor, isHslLike, isHslaColor, isInstanceOf, isKey, isNonNullable, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isOk, isPlainObject, isPrimitive, isRejected, isResult, isRgbColor, isRgbLike, isRgbaColor, isTypedArray, join, kebabCase, logger, lowerCase, max, median, memoize, merge, min, move, noop, ok, omit, once, parse, partition, pascalCase, pick, pipe, promises, push, queue, range, retry, rgbToHex, rgbToHsl, rgbToHsla, round, select, setValue, shuffle, slice, smush, snakeCase, sort, splice, startsWith, startsWithArray, sum, swap, take, template, throttle, timed, times, titleCase, toMap, toQuery, toRecord, toSet, toggle, trim, truncate, tryDecode, tryEncode, union, unique, unsmush, unwrap, update, upperCase, words };

package/dist/index.mjs

@@ -762,63 +762,72 @@ const comparators = {
 };
 //#endregion
 //#region src/array/sort.ts
-function getCallback(value, key, forObject) {
-	if (key != null) return;
-	if (forObject && typeof value.value === "function") return value.value;
-	return typeof value === "function" ? value : void 0;
-}
-function getKey(value, forObject) {
-	if (forObject && typeof value.key === "string") return value.key;
-	return typeof value === "string" ? value : void 0;
+function getComparisonSorter(callback, modifier) {
+	return {
+		modifier,
+		compare: { simple: callback },
+		get: false,
+		identifier: String(callback)
+	};
 }
-function getModifier(value, modifier, forObject) {
-	if (!forObject || typeof value.direction !== "string") return modifier;
-	if (value.direction === "ascending") return 1;
-	return value.direction === "descending" ? -1 : modifier;
+function getObjectSorter(obj, modifier) {
+	let sorter;
+	if (typeof obj.comparison === "function") sorter = getComparisonSorter(obj.comparison, modifier);
+	else if (typeof obj.key === "string") {
+		sorter = getValueSorter(obj.key, modifier);
+		if (typeof obj.compare === "function") sorter.compare = { complex: obj.compare };
+	} else if (typeof obj.value === "function") sorter = getValueSorter(obj.value, modifier);
+	if (sorter != null && typeof obj.direction === "string") sorter.modifier = modifiers[obj.direction] ?? modifier;
+	return sorter;
 }
 function getSorter(value, modifier) {
-	const forObject = isPlainObject(value);
-	const sorter = {
-		identifier: "",
-		modifier
-	};
-	sorter.compare = forObject && typeof value.compare === "function" ? value.compare : void 0;
-	sorter.key = getKey(value, forObject);
-	sorter.modifier = getModifier(value, modifier, forObject);
-	sorter.callback = getCallback(value, sorter.key, forObject);
-	if (sorter.key != null || sorter.callback != null) {
-		sorter.identifier = `${sorter.key ?? sorter.callback}`;
-		return sorter;
+	switch (true) {
+		case typeof value === "function": return getComparisonSorter(value, modifier);
+		case typeof value === "string": return getValueSorter(value, modifier);
+		case isPlainObject(value): return getObjectSorter(value, modifier);
+		default: break;
 	}
 }
+function getValueSorter(value, modifier) {
+	return {
+		modifier,
+		get: true,
+		identifier: String(value),
+		value: typeof value === "function" ? value : (item) => item[value]
+	};
+}
 function sort(array, first, second) {
 	if (!Array.isArray(array)) return [];
 	if (array.length < 2) return array;
-	const modifier = (first === true || second === true ? "descending" : "ascending") === "ascending" ? 1 : -1;
+	const modifier = modifiers[first === true || second === true ? SORT_DIRECTION_DESCENDING : SORT_DIRECTION_ASCENDING];
 	const sorters = (Array.isArray(first) ? first : [first]).map((item) => getSorter(item, modifier)).filter((sorter) => sorter != null).filter((current, index, filtered) => filtered.findIndex((next) => next.identifier === current.identifier) === index);
 	const { length } = sorters;
-	if (length === 0) return array.sort((firstItem, secondItem) => compare(firstItem, secondItem) * modifier);
+	if (length === 0) return array.sort((first, second) => compare(first, second) * modifier);
 	if (length === 1) {
 		const sorter = sorters[0];
-		const { callback, key } = sorter;
 		return array.sort((firstItem, secondItem) => {
-			const firstValue = key == null ? callback?.(firstItem) : firstItem[key];
-			const secondValue = key == null ? callback?.(secondItem) : secondItem[key];
-			return (sorter.compare?.(firstItem, firstValue, secondItem, secondValue) ?? compare(firstValue, secondValue)) * sorter.modifier;
+			const firstValue = sorter.get ? sorter.value(firstItem) : firstItem;
+			const secondValue = sorter.get ? sorter.value(secondItem) : secondItem;
+			return (sorter.compare?.complex?.(firstItem, firstValue, secondItem, secondValue) ?? sorter.compare?.simple?.(firstItem, secondItem) ?? compare(firstValue, secondValue)) * sorter.modifier;
 		});
 	}
 	return array.sort((firstItem, secondItem) => {
 		for (let index = 0; index < length; index += 1) {
 			const sorter = sorters[index];
-			const { callback, key } = sorter;
-			const firstValue = key == null ? callback?.(firstItem) : firstItem[key];
-			const secondValue = key == null ? callback?.(secondItem) : secondItem[key];
-			const compared = (sorter.compare?.(firstItem, firstValue, secondItem, secondValue) ?? compare(firstValue, secondValue)) * sorter.modifier;
-			if (compared !== 0) return compared;
+			const firstValue = sorter.value?.(firstItem) ?? firstItem;
+			const secondValue = sorter.value?.(secondItem) ?? secondItem;
+			const comparison = (sorter.compare?.complex?.(firstItem, firstValue, secondItem, secondValue) ?? sorter.compare?.simple?.(firstItem, secondItem) ?? compare(firstValue, secondValue)) * sorter.modifier;
+			if (comparison !== 0) return comparison;
 		}
 		return 0;
 	});
 }
+const SORT_DIRECTION_ASCENDING = "ascending";
+const SORT_DIRECTION_DESCENDING = "descending";
+const modifiers = {
+	[SORT_DIRECTION_ASCENDING]: 1,
+	[SORT_DIRECTION_DESCENDING]: -1
+};
 //#endregion
 //#region src/array/splice.ts
 function splice(array, start, deleteCountOrItems, items) {
@@ -868,6 +877,12 @@ function union(first, second, key) {
 	return compareSets(COMPARE_SETS_UNION, first, second, key);
 }
 //#endregion
+//#region src/array/unique.ts
+function unique(array, key) {
+	if (!Array.isArray(array)) return [];
+	return array.length > 1 ? findValues(FIND_VALUES_UNIQUE, array, [key, void 0]).matched : array;
+}
+//#endregion
 //#region src/array/update.ts
 function update(array, values, key) {
 	return updateInArray(array, values, key, true);
@@ -1043,12 +1058,6 @@ function toRecordArrays(array, first, second) {
 	return groupValues(array, first, second, true);
 }
 //#endregion
-//#region src/array/unique.ts
-function unique(array, key) {
-	if (!Array.isArray(array)) return [];
-	return array.length > 1 ? findValues(FIND_VALUES_UNIQUE, array, [key, void 0]).matched : array;
-}
-//#endregion
 //#region src/function/assert.ts
 /**
 * Asserts that a condition is true, throwing an error if it is not
@@ -4426,4 +4435,4 @@ var SizedSet = class extends Set {
 	}
 };
 //#endregion
-export { CancelablePromise, PromiseTimeoutError, QueueError, RetryError, SizedMap, SizedSet, assert, attempt, attemptPromise, average, beacon, between, camelCase, cancelable, capitalize, ceil, chunk, clamp, clone, compact, compare, count, debounce, delay, diff, difference, drop, endsWith, endsWithArray, equal, error, exists, filter, find, flatten, floor, flow, toResult as fromPromise, toResult, fromQuery, toPromise as fromResult, toPromise, getArray, getArrayPosition, getColor, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getNormalizedHex, getNumber, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getString, getUuid, getValue, groupBy, hasValue, hexToHsl, hexToHsla, hexToRgb, hexToRgba, hslToHex, hslToRgb, hslToRgba, ignoreKey, includes, includesArray, indexOf, indexOfArray, insert, intersection, isArrayOrPlainObject, isColor, isConstructor, isEmpty, isError, isFulfilled, isHexColor, isHslColor, isHslLike, isHslaColor, isInstanceOf, isKey, isNonNullable, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isOk, isPlainObject, isPrimitive, isRejected, isResult, isRgbColor, isRgbLike, isRgbaColor, isTypedArray, join, kebabCase, logger, lowerCase, max, median, memoize, merge, min, move, noop, ok, omit, once, parse, partition, pascalCase, pick, pipe, promises, push, queue, range, retry, rgbToHex, rgbToHsl, rgbToHsla, round, select, setValue, shuffle, slice, smush, snakeCase, sort, splice, startsWith, startsWithArray, sum, swap, take, template, throttle, timed, times, titleCase, toMap, toQuery, toRecord, toSet, toggle, trim, truncate, tryDecode, tryEncode, union, unique, unsmush, unwrap, update, upperCase, words };
+export { CancelablePromise, PromiseTimeoutError, QueueError, RetryError, SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, SizedMap, SizedSet, assert, attempt, attemptPromise, average, beacon, between, camelCase, cancelable, capitalize, ceil, chunk, clamp, clone, compact, compare, count, debounce, delay, diff, difference, drop, endsWith, endsWithArray, equal, error, exists, filter, find, flatten, floor, flow, toResult as fromPromise, toResult, fromQuery, toPromise as fromResult, toPromise, getArray, getArrayPosition, getColor, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getNormalizedHex, getNumber, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getString, getUuid, getValue, groupBy, hasValue, hexToHsl, hexToHsla, hexToRgb, hexToRgba, hslToHex, hslToRgb, hslToRgba, ignoreKey, includes, includesArray, indexOf, indexOfArray, insert, intersection, isArrayOrPlainObject, isColor, isConstructor, isEmpty, isError, isFulfilled, isHexColor, isHslColor, isHslLike, isHslaColor, isInstanceOf, isKey, isNonNullable, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isOk, isPlainObject, isPrimitive, isRejected, isResult, isRgbColor, isRgbLike, isRgbaColor, isTypedArray, join, kebabCase, logger, lowerCase, max, median, memoize, merge, min, move, noop, ok, omit, once, parse, partition, pascalCase, pick, pipe, promises, push, queue, range, retry, rgbToHex, rgbToHsl, rgbToHsla, round, select, setValue, shuffle, slice, smush, snakeCase, sort, splice, startsWith, startsWithArray, sum, swap, take, template, throttle, timed, times, titleCase, toMap, toQuery, toRecord, toSet, toggle, trim, truncate, tryDecode, tryEncode, union, unique, unsmush, unwrap, update, upperCase, words };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oscarpalmer/atoms",
-	"version": "0.165.2",
+	"version": "0.166.1",
 	"description": "Atomic utilities for making your JavaScript better.",
 	"keywords": [
 		"helper",
@@ -195,7 +195,7 @@
 	"devDependencies": {
 		"@types/node": "^25.5",
 		"@vitest/coverage-istanbul": "^4.1",
-		"jsdom": "^28.1",
+		"jsdom": "^29.0",
 		"tsdown": "^0.21",
 		"typescript": "^5.9",
 		"vite": "npm:@voidzero-dev/vite-plus-core@latest",

package/src/array/index.ts

@@ -16,9 +16,10 @@ export * from './position';
 export * from './push';
 export * from './select';
 export * from './slice';
-export {sort} from './sort';
+export * from './sort';
 export * from './splice';
 export * from './to-set';
 export * from './toggle';
 export * from './union';
+export * from './unique';
 export * from './update';

package/src/array/sort.ts

@@ -1,35 +1,31 @@
 import {isPlainObject} from '../internal/is';
 import {compare} from '../internal/value/compare';
-import type {GenericCallback, PlainObject, Primitive} from '../models';
+import type {PlainObject, Primitive} from '../models';
 
 // #region Types
 
 /**
- * Sorting information for arrays _(using a callback)_
+ * Sorting information for arrays _(using a comparison callback)_
  */
-export type ArrayCallbackSorter<Item> = {
+export type ArrayComparisonSorter<Item> = {
 	/**
-	 * Comparator to use when comparing items and values
+	 * Callback to use when comparing items and values
 	 */
-	compare?: (first: Item, firstValue: unknown, second: Item, secondValue: unknown) => number;
+	comparison: ComparisonSorter<Item>;
 	/**
 	 * Direction to sort by
 	 */
 	direction?: SortDirection;
-	/**
-	 * Value to sort by
-	 */
-	value: (item: Item) => unknown;
 };
 
 /**
  * Sorting information for arrays _(using a key)_
  */
-export type ArrayKeySorter<Item> = {
+export type ArrayKeySorter<Item extends PlainObject, Key extends keyof Item> = {
 	/**
 	 * Comparator to use when comparing items and values
 	 */
-	compare?: (first: Item, firstValue: unknown, second: Item, secondValue: unknown) => number;
+	compare?: CompareCallback<Item, Item[Key]>;
 	/**
 	 * Direction to sort by
 	 */
@@ -37,82 +33,150 @@ export type ArrayKeySorter<Item> = {
 	/**
 	 * Key to sort by
 	 */
-	key: keyof Item;
+	key: Key;
 };
 
-export type SortDirection = 'ascending' | 'descending';
+/**
+ * Sorters based on keys in an object
+ */
+type ArrayKeySorters<Item extends PlainObject> = {
+	[Key in keyof Item]: ArrayKeySorter<Item, Key>;
+}[keyof Item];
+
+/**
+ * Sorting information for arrays _(using a value callback and built-in comparison)_
+ */
+export type ArrayValueSorter<Item> = {
+	/**
+	 * Direction to sort by
+	 */
+	direction?: SortDirection;
+	/**
+	 * Value to sort by
+	 */
+	value: (item: Item) => unknown;
+};
 
-type Sorter = {
-	callback?: (item: unknown) => unknown;
-	compare?: (first: unknown, firstValue: unknown, second: unknown, secondValue: unknown) => number;
+/**
+ * Comparator to use when comparing items and values
+ */
+type CompareCallback<Item, Value = CompareCallbackValue<Item>> = (
+	first: Item,
+	firstValue: Value,
+	second: Item,
+	secondValue: Value,
+) => number;
+
+type CompareCallbackValue<Item> = Item extends Primitive ? Item : unknown;
+
+/**
+ * Callback to use when comparing items and values
+ */
+type ComparisonSorter<Item> = (first: Item, second: Item) => number;
+
+/**
+ * Internal sorter information
+ */
+type InternalSorter = {
+	compare?: SorterCompare;
+	get: boolean;
 	identifier: string;
-	key?: string;
 	modifier: number;
-	sorter?: (first: unknown, firstValue: unknown, second: unknown, secondValue: unknown) => number;
+	value?: (item: PlainObject) => unknown;
 };
 
-// #endregion
+/**
+ * Direction to sort by
+ */
+export type SortDirection = 'ascending' | 'descending';
 
-// #region Functions
+/**
+ * Comparison callbacks for sorter
+ */
+type SorterCompare = {
+	complex?: Function;
+	simple?: Function;
+};
 
-function getCallback(
-	value: unknown,
-	key: string | undefined,
-	forObject: boolean,
-): GenericCallback | undefined {
-	if (key != null) {
-		return;
-	}
+/**
+ * Sorter to use for sorting
+ */
+type Sorter<Item> = Item extends PlainObject
+	?
+			| keyof Item
+			| ArrayComparisonSorter<Item>
+			| ArrayKeySorters<Item>
+			| ArrayValueSorter<Item>
+			| ComparisonSorter<Item>
+	: ArrayComparisonSorter<Item> | ArrayValueSorter<Item> | ComparisonSorter<Item>;
 
-	if (forObject && typeof (value as PlainObject).value === 'function') {
-		return (value as PlainObject).value as never;
-	}
+// #endregion
 
-	return typeof value === 'function' ? (value as never) : undefined;
+// #region Functions
+
+function getComparisonSorter(callback: Function, modifier: number): InternalSorter {
+	return {
+		modifier,
+		compare: {
+			simple: callback,
+		},
+		get: false,
+		identifier: String(callback),
+	};
 }
 
-function getKey(value: unknown, forObject: boolean): string | undefined {
-	if (forObject && typeof (value as PlainObject).key === 'string') {
-		return (value as PlainObject).key as string;
-	}
+function getObjectSorter(obj: PlainObject, modifier: number): InternalSorter | undefined {
+	let sorter: InternalSorter | undefined;
 
-	return typeof value === 'string' ? value : undefined;
-}
+	if (typeof obj.comparison === 'function') {
+		sorter = getComparisonSorter(obj.comparison, modifier);
+	} else if (typeof obj.key === 'string') {
+		sorter = getValueSorter(obj.key, modifier);
 
-function getModifier(value: unknown, modifier: number, forObject: boolean): number {
-	if (!forObject || typeof (value as PlainObject).direction !== 'string') {
-		return modifier;
+		if (typeof obj.compare === 'function') {
+			sorter.compare = {
+				complex: obj.compare,
+			};
+		}
+	} else if (typeof obj.value === 'function') {
+		sorter = getValueSorter(obj.value, modifier);
 	}
 
-	if ((value as PlainObject).direction === SORT_DIRECTION_ASCENDING) {
-		return 1;
+	if (sorter != null && typeof obj.direction === 'string') {
+		sorter.modifier = modifiers[obj.direction as SortDirection] ?? modifier;
 	}
 
-	return (value as PlainObject).direction === SORT_DIRECTION_DESCENDING ? -1 : modifier;
+	return sorter;
 }
 
-function getSorter(value: unknown, modifier: number): Sorter | undefined {
-	const forObject = isPlainObject(value);
-
-	const sorter: Sorter = {
-		identifier: '',
-		modifier,
-	};
-
-	sorter.compare =
-		forObject && typeof value.compare === 'function' ? (value.compare as never) : undefined;
+function getSorter(value: unknown, modifier: number): InternalSorter | undefined {
+	switch (true) {
+		case typeof value === 'function':
+			return getComparisonSorter(value, modifier);
 
-	sorter.key = getKey(value, forObject);
-	sorter.modifier = getModifier(value, modifier, forObject);
-	sorter.callback = getCallback(value, sorter.key, forObject);
+		case typeof value === 'string':
+			return getValueSorter(value, modifier);
 
-	if (sorter.key != null || sorter.callback != null) {
-		sorter.identifier = `${sorter.key ?? sorter.callback}`;
+		case isPlainObject(value):
+			return getObjectSorter(value, modifier);
 
-		return sorter;
+		default:
+			break;
 	}
 }
 
+function getValueSorter(value: string | Function, modifier: number): InternalSorter {
+	return {
+		modifier,
+		get: true,
+		identifier: String(value),
+		value:
+			typeof value === 'function'
+				? (value as (item: PlainObject) => unknown)
+				: item => (item as PlainObject)[value],
+	};
+}
+
 /**
  * Sort an array of items, using multiple sorters to sort by specific values
  * @param array Array to sort
@@ -122,76 +186,18 @@ function getSorter(value: unknown, modifier: number): Sorter | undefined {
  */
 export function sort<Item>(
 	array: Item[],
-	sorters: Array<((item: Item) => unknown) | ArrayCallbackSorter<Item>>,
-	descending?: boolean,
-): Item[];
-
-/**
- * Sort an array of items, using a sorter to sort by a specific value
- * @param array Array to sort
- * @param sorter Sorter to use for sorting
- * @param descending Sort in descending order? _(defaults to `false`; overridden by the sorter)_
- * @returns Sorted array
- */
-export function sort<Item>(
-	array: Item[],
-	sorter: ((item: Item) => unknown) | ArrayCallbackSorter<Item>,
+	sorters: Array<Sorter<Item>>,
 	descending?: boolean,
 ): Item[];
 
 /**
  * Sort an array of items, using multiple sorters to sort by specific values
  * @param array Array to sort
- * @param sorters Sorters to use for sorting
- * @param descending Sort in descending order? _(defaults to `false`; overridden by individual sorters)_
- * @returns Sorted array
- */
-export function sort<Item extends PlainObject>(
-	array: Item[],
-	sorters: Array<
-		keyof Item | ((item: Item) => unknown) | ArrayCallbackSorter<Item> | ArrayKeySorter<Item>
-	>,
-	descending?: boolean,
-): Item[];
-
-/**
- * Sort an array of items, using a sorter to sort by a specific value
- * @param array Array to sort
  * @param sorter Sorter to use for sorting
- * @param descending Sort in descending order? _(defaults to `false`; overridden by the sorter)_
- * @returns Sorted array
- */
-export function sort<Item extends PlainObject>(
-	array: Item[],
-	sorter: keyof Item | ((item: Item) => unknown) | ArrayCallbackSorter<Item> | ArrayKeySorter<Item>,
-	descending?: boolean,
-): Item[];
-
-/**
- * Sort an array of items, using multiple sorters to sort by specific values
- * @param array Array to sort
- * @param sorters Sorters to use for sorting
  * @param descending Sort in descending order? _(defaults to `false`; overridden by individual sorters)_
  * @returns Sorted array
  */
-export function sort<Item extends Primitive>(
-	array: Item[],
-	sorters: ((item: Item) => unknown)[],
-	descending?: boolean,
-): Item[];
-
-/**
- * Sort an array of items, using a sorter to sort by a specific value
- * @param array Array to sort
- * @param sorter Sorter to use for sorting
- * @param descending Sort in descending order? _(defaults to `false`; overridden by the sorter)_
- * @returns Sorted array
- */
-export function sort<Item extends Primitive>(
-	array: Item[],
-	sorter: (item: Item) => unknown,
-	descending?: boolean,
-): Item[];
+export function sort<Item>(array: Item[], sorter: Sorter<Item>, descending?: boolean): Item[];
 
 /**
  * Sort an array of items
@@ -213,7 +219,7 @@ export function sort(array: unknown[], first?: unknown, second?: unknown): unkno
 	const direction =
 		first === true || second === true ? SORT_DIRECTION_DESCENDING : SORT_DIRECTION_ASCENDING;
 
-	const modifier = direction === SORT_DIRECTION_ASCENDING ? 1 : -1;
+	const modifier = modifiers[direction];
 
 	const sorters = (Array.isArray(first) ? first : [first])
 		.map(item => getSorter(item, modifier))
@@ -226,21 +232,19 @@ export function sort(array: unknown[], first?: unknown, second?: unknown): unkno
 	const {length} = sorters;
 
 	if (length === 0) {
-		return array.sort(
-			(firstItem, secondItem) => compare(firstItem as never, secondItem as never) * modifier,
-		);
+		return array.sort((first, second) => compare(first, second) * modifier);
 	}
 
 	if (length === 1) {
 		const sorter = sorters[0];
-		const {callback, key} = sorter;
 
 		return array.sort((firstItem, secondItem) => {
-			const firstValue = key == null ? callback?.(firstItem) : (firstItem as PlainObject)[key];
-			const secondValue = key == null ? callback?.(secondItem) : (secondItem as PlainObject)[key];
+			const firstValue = sorter.get ? sorter.value!(firstItem as PlainObject) : firstItem;
+			const secondValue = sorter.get ? sorter.value!(secondItem as PlainObject) : secondItem;
 
 			return (
-				(sorter.compare?.(firstItem, firstValue, secondItem, secondValue) ??
+				(sorter.compare?.complex?.(firstItem, firstValue, secondItem, secondValue) ??
+					sorter.compare?.simple?.(firstItem, secondItem) ??
 					compare(firstValue, secondValue)) * sorter.modifier
 			);
 		});
@@ -249,17 +253,17 @@ export function sort(array: unknown[], first?: unknown, second?: unknown): unkno
 	return array.sort((firstItem, secondItem) => {
 		for (let index = 0; index < length; index += 1) {
 			const sorter = sorters[index];
-			const {callback, key} = sorter;
 
-			const firstValue = key == null ? callback?.(firstItem) : (firstItem as PlainObject)[key];
-			const secondValue = key == null ? callback?.(secondItem) : (secondItem as PlainObject)[key];
+			const firstValue = sorter.value?.(firstItem as PlainObject) ?? firstItem;
+			const secondValue = sorter.value?.(secondItem as PlainObject) ?? secondItem;
 
-			const compared =
-				(sorter.compare?.(firstItem, firstValue, secondItem, secondValue) ??
+			const comparison =
+				(sorter.compare?.complex?.(firstItem, firstValue, secondItem, secondValue) ??
+					sorter.compare?.simple?.(firstItem, secondItem) ??
 					compare(firstValue, secondValue)) * sorter.modifier;
 
-			if (compared !== 0) {
-				return compared;
+			if (comparison !== 0) {
+				return comparison;
 			}
 		}
 
@@ -275,4 +279,9 @@ export const SORT_DIRECTION_ASCENDING: SortDirection = 'ascending';
 
 export const SORT_DIRECTION_DESCENDING: SortDirection = 'descending';
 
+const modifiers: Record<SortDirection, number> = {
+	[SORT_DIRECTION_ASCENDING]: 1,
+	[SORT_DIRECTION_DESCENDING]: -1,
+};
+
 // #endregion