@oscarpalmer/atoms 0.165.1 → 0.166.0

package/dist/array/index.d.mts

@@ -15,10 +15,10 @@ 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 { 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, update };

package/dist/array/index.mjs

@@ -15,10 +15,10 @@ 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 { 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, 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)_
+ */
+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
@@ -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
 /**
@@ -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) {
@@ -3659,31 +3668,6 @@ function sum(array, key) {
 	return getAggregated("sum", array, key);
 }
 //#endregion
-//#region src/result/match.ts
-async function asyncMatchResult(result, first, error) {
-	let value;
-	if (typeof result === "function") value = await result();
-	else if (result instanceof Promise) value = await result;
-	else value = result;
-	if (!isResult(value)) throw new Error(MESSAGE_RESULT);
-	const hasObj = typeof first === "object" && first !== null;
-	const okHandler = hasObj ? first.ok : first;
-	const errorHandler = hasObj ? first.error : error;
-	if (isOk(value)) return okHandler(value.value);
-	return errorHandler(value.error, value.original);
-}
-function matchResult(result, first, error) {
-	const value = typeof result === "function" ? result() : result;
-	if (!isResult(value)) throw new Error(MESSAGE_RESULT);
-	const hasObj = typeof first === "object" && first !== null;
-	const okHandler = hasObj ? first.ok : first;
-	const errorHandler = hasObj ? first.error : error;
-	if (isOk(value)) return okHandler(value.value);
-	return errorHandler(value.error, value.original);
-}
-matchResult.async = asyncMatchResult;
-const MESSAGE_RESULT = "`result.match` expected a Result or a function that returns a Result";
-//#endregion
 //#region src/result/misc.ts
 function error(value, original) {
 	return getError(value, original);
@@ -3724,48 +3708,6 @@ function unwrap(value, defaultValue) {
 }
 const MESSAGE_PROMISE_RESULT = "toPromise expected to receive a Result";
 //#endregion
-//#region src/result/work/flow.ts
-function attemptAsyncFlow(...fns) {
-	let Flow;
-	return (...args) => attempt.async(() => {
-		Flow ??= flow.async(...fns);
-		return Flow(...args.map((value) => {
-			if (isError(value)) throw value.error;
-			return isOk(value) ? value.value : value;
-		}));
-	});
-}
-function attemptFlow(...fns) {
-	let Flow;
-	return (...args) => attempt(() => {
-		Flow ??= flow(...fns);
-		return Flow(...args.map((value) => {
-			if (isError(value)) throw value.error;
-			return isOk(value) ? value.value : value;
-		}));
-	});
-}
-attemptFlow.async = attemptAsyncFlow;
-//#endregion
-//#region src/result/work/pipe.ts
-async function attemptAsyncPipe(initial, first, ...seconds) {
-	return attempt.async(() => {
-		if (isError(initial)) throw initial.error;
-		const value = typeof initial === "function" ? initial() : isOk(initial) ? initial.value : initial;
-		if (first == null) return value;
-		return pipe.async(value, ...[first, ...seconds]);
-	});
-}
-function attemptPipe(initial, first, ...seconds) {
-	return attempt(() => {
-		if (isError(initial)) throw initial.error;
-		const value = typeof initial === "function" ? initial() : isOk(initial) ? initial.value : initial;
-		if (first == null) return value;
-		return pipe(value, ...[first, ...seconds]);
-	});
-}
-attemptPipe.async = attemptAsyncPipe;
-//#endregion
 //#region src/promise/models.ts
 var CancelablePromise = class extends Promise {
 	#rejector;
@@ -3803,64 +3745,6 @@ const PROMISE_STRATEGY_DEFAULT = "complete";
 const PROMISE_TYPE_FULFILLED = "fulfilled";
 const PROMISE_TYPE_REJECTED = "rejected";
 //#endregion
-//#region src/promise/misc.ts
-/**
-* Create a cancelable promise
-* @param executor Executor function for the promise
-* @returns Cancelable promise
-*/
-function cancelable(executor) {
-	return new CancelablePromise(executor);
-}
-function handleResult$1(status, parameters) {
-	const { abort, complete, data, handlers, index, signal, value } = parameters;
-	if (signal?.aborted ?? false) return;
-	if (!complete && status === "rejected") {
-		settlePromise(abort, handlers.reject, value, signal);
-		return;
-	}
-	data.result[index] = !complete ? value : status === "fulfilled" ? {
-		status,
-		value
-	} : {
-		status,
-		reason: value
-	};
-	if (index === data.last) settlePromise(abort, handlers.resolve, data.result, signal);
-}
-function settlePromise(aborter, settler, value, signal) {
-	signal?.removeEventListener(PROMISE_ABORT_EVENT, aborter);
-	settler(value);
-}
-async function toResult(value) {
-	const actual = typeof value === "function" ? value() : value;
-	if (!(actual instanceof Promise)) return Promise.reject(new TypeError(PROMISE_MESSAGE_EXPECTATION_RESULT));
-	return actual.then((result) => ok(result)).catch((reason) => error(reason));
-}
-//#endregion
-//#region src/result/index.ts
-async function asyncAttempt(value, err) {
-	try {
-		let result = typeof value === "function" ? value() : await value;
-		if (result instanceof Promise) result = await result;
-		return ok(result);
-	} catch (thrown) {
-		return getError(err ?? thrown, err == null ? void 0 : thrown);
-	}
-}
-function attempt(callback, err) {
-	try {
-		return ok(callback());
-	} catch (thrown) {
-		return getError(err ?? thrown, err == null ? void 0 : thrown);
-	}
-}
-attempt.async = asyncAttempt;
-attempt.flow = attemptFlow;
-attempt.match = matchResult;
-attempt.pipe = attemptPipe;
-attempt.promise = attemptPromise;
-//#endregion
 //#region src/promise/helpers.ts
 function getNumberOrDefault$1(value) {
 	return typeof value === "number" && value > 0 ? value : 0;
@@ -3915,6 +3799,41 @@ function isType(value, type) {
 	return typeof value === "object" && value !== null && value.status === type;
 }
 //#endregion
+//#region src/promise/misc.ts
+/**
+* Create a cancelable promise
+* @param executor Executor function for the promise
+* @returns Cancelable promise
+*/
+function cancelable(executor) {
+	return new CancelablePromise(executor);
+}
+function handleResult$1(status, parameters) {
+	const { abort, complete, data, handlers, index, signal, value } = parameters;
+	if (signal?.aborted ?? false) return;
+	if (!complete && status === "rejected") {
+		settlePromise(abort, handlers.reject, value, signal);
+		return;
+	}
+	data.result[index] = !complete ? value : status === "fulfilled" ? {
+		status,
+		value
+	} : {
+		status,
+		reason: value
+	};
+	if (index === data.last) settlePromise(abort, handlers.resolve, data.result, signal);
+}
+function settlePromise(aborter, settler, value, signal) {
+	signal?.removeEventListener(PROMISE_ABORT_EVENT, aborter);
+	settler(value);
+}
+async function toResult(value) {
+	const actual = typeof value === "function" ? value() : value;
+	if (!(actual instanceof Promise)) return Promise.reject(new TypeError(PROMISE_MESSAGE_EXPECTATION_RESULT));
+	return actual.then((result) => ok(result)).catch((reason) => error(reason));
+}
+//#endregion
 //#region src/promise/timed.ts
 async function getTimedPromise(promise, time, signal) {
 	function abort() {
@@ -4372,6 +4291,96 @@ const BOOLEAN_MODIFIER = .5;
 const HEX_CHARACTERS = "0123456789ABCDEF";
 const HEX_MAXIMUM = 15;
 //#endregion
+//#region src/result/match.ts
+async function asyncMatchResult(result, first, error) {
+	let value;
+	if (typeof result === "function") value = await result();
+	else if (result instanceof Promise) value = await result;
+	else value = result;
+	if (!isResult(value)) throw new Error(MESSAGE_RESULT);
+	const hasObj = typeof first === "object" && first !== null;
+	const okHandler = hasObj ? first.ok : first;
+	const errorHandler = hasObj ? first.error : error;
+	if (isOk(value)) return okHandler(value.value);
+	return errorHandler(value.error, value.original);
+}
+function matchResult(result, first, error) {
+	const value = typeof result === "function" ? result() : result;
+	if (!isResult(value)) throw new Error(MESSAGE_RESULT);
+	const hasObj = typeof first === "object" && first !== null;
+	const okHandler = hasObj ? first.ok : first;
+	const errorHandler = hasObj ? first.error : error;
+	if (isOk(value)) return okHandler(value.value);
+	return errorHandler(value.error, value.original);
+}
+matchResult.async = asyncMatchResult;
+const MESSAGE_RESULT = "`result.match` expected a Result or a function that returns a Result";
+//#endregion
+//#region src/result/work/flow.ts
+function attemptAsyncFlow(...fns) {
+	let Flow;
+	return (...args) => attempt.async(() => {
+		Flow ??= flow.async(...fns);
+		return Flow(...args.map((value) => {
+			if (isError(value)) throw value.error;
+			return isOk(value) ? value.value : value;
+		}));
+	});
+}
+function attemptFlow(...fns) {
+	let Flow;
+	return (...args) => attempt(() => {
+		Flow ??= flow(...fns);
+		return Flow(...args.map((value) => {
+			if (isError(value)) throw value.error;
+			return isOk(value) ? value.value : value;
+		}));
+	});
+}
+attemptFlow.async = attemptAsyncFlow;
+//#endregion
+//#region src/result/work/pipe.ts
+async function attemptAsyncPipe(initial, first, ...seconds) {
+	return attempt.async(() => {
+		if (isError(initial)) throw initial.error;
+		const value = typeof initial === "function" ? initial() : isOk(initial) ? initial.value : initial;
+		if (first == null) return value;
+		return pipe.async(value, ...[first, ...seconds]);
+	});
+}
+function attemptPipe(initial, first, ...seconds) {
+	return attempt(() => {
+		if (isError(initial)) throw initial.error;
+		const value = typeof initial === "function" ? initial() : isOk(initial) ? initial.value : initial;
+		if (first == null) return value;
+		return pipe(value, ...[first, ...seconds]);
+	});
+}
+attemptPipe.async = attemptAsyncPipe;
+//#endregion
+//#region src/result/index.ts
+async function asyncAttempt(value, err) {
+	try {
+		let result = typeof value === "function" ? value() : await value;
+		if (result instanceof Promise) result = await result;
+		return ok(result);
+	} catch (thrown) {
+		return getError(err ?? thrown, err == null ? void 0 : thrown);
+	}
+}
+function attempt(callback, err) {
+	try {
+		return ok(callback());
+	} catch (thrown) {
+		return getError(err ?? thrown, err == null ? void 0 : thrown);
+	}
+}
+attempt.async = asyncAttempt;
+attempt.flow = attemptFlow;
+attempt.match = matchResult;
+attempt.pipe = attemptPipe;
+attempt.promise = attemptPromise;
+//#endregion
 //#region src/sized/set.ts
 /**
 * - A Set with a maximum size
@@ -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/dist/promise/delay.mjs

@@ -1,7 +1,7 @@
 import { TIMER_WAIT, getTimer } from "../internal/function/timer.mjs";
 import { PROMISE_ABORT_EVENT, PROMISE_ABORT_OPTIONS } from "./models.mjs";
-import { settlePromise } from "./misc.mjs";
 import { getPromiseOptions } from "./helpers.mjs";
+import { settlePromise } from "./misc.mjs";
 //#region src/promise/delay.ts
 function delay(options) {
 	const { signal, time } = getPromiseOptions(options);

package/dist/promise/helpers.mjs

@@ -1,6 +1,5 @@
 import { error, ok } from "../result/misc.mjs";
 import { PROMISE_STRATEGY_ALL, PROMISE_STRATEGY_DEFAULT, PROMISE_TYPE_FULFILLED, PROMISE_TYPE_REJECTED } from "./models.mjs";
-import "../result/index.mjs";
 //#region src/promise/helpers.ts
 function getNumberOrDefault(value) {
 	return typeof value === "number" && value > 0 ? value : 0;

package/dist/promise/index.mjs

@@ -1,7 +1,7 @@
 import { toPromise } from "../result/misc.mjs";
 import { CancelablePromise, PROMISE_ABORT_EVENT, PROMISE_ABORT_OPTIONS, PROMISE_MESSAGE_EXPECTATION_ATTEMPT, PROMISE_STRATEGY_DEFAULT, PROMISE_TYPE_FULFILLED, PROMISE_TYPE_REJECTED, PromiseTimeoutError } from "./models.mjs";
-import { cancelable, handleResult, settlePromise, toResult } from "./misc.mjs";
 import { getPromiseOptions, getPromisesOptions, getResultsFromPromises, isFulfilled, isRejected } from "./helpers.mjs";
+import { cancelable, handleResult, settlePromise, toResult } from "./misc.mjs";
 import { getTimedPromise, timed } from "./timed.mjs";
 import { delay } from "./delay.mjs";
 //#region src/promise/index.ts

package/dist/promise/timed.mjs

@@ -1,7 +1,7 @@
 import { TIMER_WAIT, getTimer } from "../internal/function/timer.mjs";
 import { PROMISE_ABORT_EVENT, PROMISE_ABORT_OPTIONS, PROMISE_MESSAGE_EXPECTATION_TIMED, PromiseTimeoutError } from "./models.mjs";
-import { settlePromise } from "./misc.mjs";
 import { getPromiseOptions } from "./helpers.mjs";
+import { settlePromise } from "./misc.mjs";
 //#region src/promise/timed.ts
 async function getTimedPromise(promise, time, signal) {
 	function abort() {

package/dist/result/index.mjs

@@ -1,10 +1,10 @@
 import { isError, isOk, isResult } from "../internal/result.mjs";
-import { matchResult } from "./match.mjs";
 import { error, getError, ok, toPromise, unwrap } from "./misc.mjs";
-import { attemptFlow } from "./work/flow.mjs";
-import { attemptPipe } from "./work/pipe.mjs";
 import { toResult } from "../promise/misc.mjs";
 import { attemptPromise } from "../promise/index.mjs";
+import { matchResult } from "./match.mjs";
+import { attemptFlow } from "./work/flow.mjs";
+import { attemptPipe } from "./work/pipe.mjs";
 //#region src/result/index.ts
 async function asyncAttempt(value, err) {
 	try {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oscarpalmer/atoms",
-	"version": "0.165.1",
+	"version": "0.166.0",
 	"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,7 +16,7 @@ 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';

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

package/src/promise/helpers.ts

@@ -1,5 +1,5 @@
 import type {RequiredKeys} from '../models';
-import {error, ok} from '../result';
+import {error, ok} from '../result/misc';
 import type {Result} from '../result/models';
 import {
 	PROMISE_STRATEGY_ALL,