@oscarpalmer/atoms 0.167.0 → 0.168.0

package/dist/array/index.d.mts

@@ -15,11 +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 { 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 { 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 };
+export { ArrayPosition, chunk, compact, difference, drop, endsWithArray, exists, find, flatten, getArray, getArrayPosition, includesArray, indexOf, indexOfArray, insert, intersection, partition, push, range, select, shuffle, slice, splice, startsWithArray, take, times, toSet, toggle, union, unique, update };

package/dist/array/index.mjs

@@ -15,11 +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_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 { 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 };
+export { chunk, compact, difference, drop, endsWithArray, exists, find, flatten, getArray, getArrayPosition, includesArray, indexOf, indexOfArray, insert, intersection, partition, push, range, select, shuffle, slice, splice, startsWithArray, take, times, toSet, toggle, union, unique, update };

package/dist/array/sort.d.mts

@@ -35,6 +35,10 @@ type ArrayKeySorter<Item extends PlainObject, ItemKey extends keyof Item> = {
  * Sorters based on keys in an object
  */
 type ArrayKeySorters<Item extends PlainObject> = { [ItemKey in keyof Item]: ArrayKeySorter<Item, ItemKey> }[keyof Item];
+/**
+ * Sorter to use for sorting
+ */
+type ArraySorter<Item> = Item extends PlainObject ? keyof Item | ArrayComparisonSorter<Item> | ArrayKeySorters<Item> | ArrayValueSorter<Item> | ComparisonSorter<Item> : ArrayComparisonSorter<Item> | ArrayValueSorter<Item> | ComparisonSorter<Item>;
 /**
  * Sorting information for arrays _(using a value callback and built-in comparison)_
  */
@@ -61,10 +65,27 @@ type ComparisonSorter<Item> = (first: Item, second: Item) => number;
  * Direction to sort by
  */
 type SortDirection = 'ascending' | 'descending';
+type Sorter<Item> = (array: Item[]) => Item[];
 /**
- * Sorter to use for sorting
+ * Initialize a sort handler with sorters _(and an optional default direction)_
+ * @param sorters Sorters to use for sorting
+ * @param descending Sort in descending order? _(defaults to `false`; overridden by individual sorters)_
+ * @returns Sort handler
+ */
+declare function initializeSort<Item>(sorters: Array<ArraySorter<Item>>, descending?: boolean): Sorter<Item>;
+/**
+ * Initialize a sort handler with a sorter _(and an optional default direction)_
+ * @param sorter Sorter to use for sorting
+ * @param descending Sort in descending order? _(defaults to `false`; overridden by individual sorters)_
+ * @returns Sort handler
+ */
+declare function initializeSort<Item>(sorter: ArraySorter<Item>, descending?: boolean): Sorter<Item>;
+/**
+ * Initialize a sort handler _(with an optional default direction)_
+ * @param descending Sort in descending order? _(defaults to `false`)_
+ * @returns Sort handler
  */
-type Sorter<Item> = Item extends PlainObject ? keyof Item | ArrayComparisonSorter<Item> | ArrayKeySorters<Item> | ArrayValueSorter<Item> | ComparisonSorter<Item> : ArrayComparisonSorter<Item> | ArrayValueSorter<Item> | ComparisonSorter<Item>;
+declare function initializeSort<Item>(descending?: boolean): Sorter<Item>;
 /**
  * Sort an array of items, using multiple sorters to sort by specific values
  * @param array Array to sort
@@ -72,7 +93,7 @@ type Sorter<Item> = Item extends PlainObject ? keyof Item | ArrayComparisonSorte
  * @param descending Sort in descending order? _(defaults to `false`; overridden by individual sorters)_
  * @returns Sorted array
  */
-declare function sort<Item>(array: Item[], sorters: Array<Sorter<Item>>, descending?: boolean): Item[];
+declare function sort<Item>(array: Item[], sorters: Array<ArraySorter<Item>>, descending?: boolean): Item[];
 /**
  * Sort an array of items, using multiple sorters to sort by specific values
  * @param array Array to sort
@@ -80,7 +101,7 @@ declare function sort<Item>(array: Item[], sorters: Array<Sorter<Item>>, descend
  * @param descending Sort in descending order? _(defaults to `false`; overridden by individual sorters)_
  * @returns Sorted array
  */
-declare function sort<Item>(array: Item[], sorter: Sorter<Item>, descending?: boolean): Item[];
+declare function sort<Item>(array: Item[], sorter: ArraySorter<Item>, descending?: boolean): Item[];
 /**
  * Sort an array of items
  * @param array Array to sort
@@ -88,7 +109,10 @@ declare function sort<Item>(array: Item[], sorter: Sorter<Item>, descending?: bo
  * @returns Sorted array
  */
 declare function sort<Item>(array: Item[], descending?: boolean): Item[];
+declare namespace sort {
+  var initialize: typeof initializeSort;
+}
 declare const SORT_DIRECTION_ASCENDING: SortDirection;
 declare const SORT_DIRECTION_DESCENDING: SortDirection;
 //#endregion
-export { ArrayComparisonSorter, ArrayKeySorter, ArrayValueSorter, SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, SortDirection, sort };
+export { ArrayComparisonSorter, ArrayKeySorter, ArrayValueSorter, SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, SortDirection, Sorter, sort };

package/dist/array/sort.mjs

@@ -9,6 +9,9 @@ function getComparisonSorter(callback, modifier) {
 		identifier: String(callback)
 	};
 }
+function getModifier(first, second) {
+	return modifiers[first === true || second === true ? SORT_DIRECTION_DESCENDING : SORT_DIRECTION_ASCENDING];
+}
 function getObjectSorter(obj, modifier) {
 	let sorter;
 	if (typeof obj.comparison === "function") sorter = getComparisonSorter(obj.comparison, modifier);
@@ -27,6 +30,17 @@ function getSorter(value, modifier) {
 		default: break;
 	}
 }
+function getSorters(value, modifier) {
+	const array = Array.isArray(value) ? value : [value];
+	const { length } = array;
+	const sorters = [];
+	for (let index = 0; index < length; index += 1) {
+		const item = array[index];
+		const sorter = getSorter(item, modifier);
+		if (sorter != null) sorters.push(sorter);
+	}
+	return sorters.filter((value, index, array) => array.findIndex((next) => next.identifier === value.identifier) === index);
+}
 function getValueSorter(value, modifier) {
 	return {
 		modifier,
@@ -35,32 +49,31 @@ function getValueSorter(value, modifier) {
 		value: typeof value === "function" ? value : (item) => item[value]
 	};
 }
+function initializeSort(first, second) {
+	const modifier = getModifier(first, second);
+	const sorters = getSorters(first, modifier);
+	return (array) => work(array, sorters, modifier);
+}
 function sort(array, first, second) {
+	const modifier = getModifier(first, second);
+	return work(array, getSorters(first, modifier), modifier);
+}
+function work(array, sorters, modifier) {
 	if (!Array.isArray(array)) return [];
 	if (array.length < 2) return array;
-	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((first, second) => compare(first, second) * modifier);
-	if (length === 1) {
-		const sorter = sorters[0];
-		return array.sort((firstItem, secondItem) => {
-			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) => {
+	return array.sort((first, second) => {
 		for (let index = 0; index < length; index += 1) {
 			const sorter = sorters[index];
-			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;
+			const values = [sorter.get ? sorter.value(first) : first, sorter.get ? sorter.value(second) : second];
+			const comparison = (sorter.compare?.complex?.(first, values[0], second, values[1]) ?? sorter.compare?.simple?.(values[0], values[1]) ?? compare(values[0], values[1])) * sorter.modifier;
 			if (comparison !== 0) return comparison;
 		}
 		return 0;
 	});
 }
+sort.initialize = initializeSort;
 const SORT_DIRECTION_ASCENDING = "ascending";
 const SORT_DIRECTION_DESCENDING = "descending";
 const modifiers = {

package/dist/index.d.mts

@@ -853,97 +853,6 @@ declare function take<Item extends PlainObject>(array: Item[], callback: (item:
  */
 declare function take(array: unknown[], count: number): unknown[];
 //#endregion
-//#region src/array/sort.d.ts
-/**
- * Sorting information for arrays _(using a comparison callback)_
- */
-type ArrayComparisonSorter<Item> = {
-  /**
-   * Callback to use when comparing items and values
-   */
-  comparison: ComparisonSorter<Item>;
-  /**
-   * Direction to sort by
-   */
-  direction?: SortDirection;
-};
-/**
- * Sorting information for arrays _(using a key)_
- */
-type ArrayKeySorter<Item extends PlainObject, ItemKey extends keyof Item> = {
-  /**
-   * Comparator to use when comparing items and values
-   */
-  compare?: CompareCallback<Item, Item[ItemKey]>;
-  /**
-   * Direction to sort by
-   */
-  direction?: SortDirection;
-  /**
-   * Key to sort by
-   */
-  key: ItemKey;
-};
-/**
- * Sorters based on keys in an object
- */
-type ArrayKeySorters<Item extends PlainObject> = { [ItemKey in keyof Item]: ArrayKeySorter<Item, ItemKey> }[keyof Item];
-/**
- * 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
- */
-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;
-/**
- * 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
- * @param sorters Sorters to use for sorting
- * @param descending Sort in descending order? _(defaults to `false`; overridden by individual sorters)_
- * @returns Sorted array
- */
-declare function sort<Item>(array: 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 sorter Sorter to use for sorting
- * @param descending Sort in descending order? _(defaults to `false`; overridden by individual sorters)_
- * @returns Sorted array
- */
-declare function sort<Item>(array: Item[], sorter: Sorter<Item>, descending?: boolean): Item[];
-/**
- * Sort an array of items
- * @param array Array to sort
- * @param descending Sort in descending order? _(defaults to `false`)_
- * @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
 /**
  * Adds items into an array at a specific index and removes a specific amount of items
@@ -1183,6 +1092,121 @@ declare function moveToIndex<Item>(array: Item[], value: Item | Item[], index: n
  */
 declare function moveToIndex<Item>(array: Item[], value: Item | Item[], index: number): Item[];
 //#endregion
+//#region src/array/sort.d.ts
+/**
+ * Sorting information for arrays _(using a comparison callback)_
+ */
+type ArrayComparisonSorter<Item> = {
+  /**
+   * Callback to use when comparing items and values
+   */
+  comparison: ComparisonSorter<Item>;
+  /**
+   * Direction to sort by
+   */
+  direction?: SortDirection;
+};
+/**
+ * Sorting information for arrays _(using a key)_
+ */
+type ArrayKeySorter<Item extends PlainObject, ItemKey extends keyof Item> = {
+  /**
+   * Comparator to use when comparing items and values
+   */
+  compare?: CompareCallback<Item, Item[ItemKey]>;
+  /**
+   * Direction to sort by
+   */
+  direction?: SortDirection;
+  /**
+   * Key to sort by
+   */
+  key: ItemKey;
+};
+/**
+ * Sorters based on keys in an object
+ */
+type ArrayKeySorters<Item extends PlainObject> = { [ItemKey in keyof Item]: ArrayKeySorter<Item, ItemKey> }[keyof Item];
+/**
+ * Sorter to use for sorting
+ */
+type ArraySorter<Item> = Item extends PlainObject ? keyof Item | ArrayComparisonSorter<Item> | ArrayKeySorters<Item> | ArrayValueSorter<Item> | ComparisonSorter<Item> : ArrayComparisonSorter<Item> | ArrayValueSorter<Item> | ComparisonSorter<Item>;
+/**
+ * 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
+ */
+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;
+/**
+ * Direction to sort by
+ */
+type SortDirection = 'ascending' | 'descending';
+type Sorter<Item> = (array: Item[]) => Item[];
+/**
+ * Initialize a sort handler with sorters _(and an optional default direction)_
+ * @param sorters Sorters to use for sorting
+ * @param descending Sort in descending order? _(defaults to `false`; overridden by individual sorters)_
+ * @returns Sort handler
+ */
+declare function initializeSort<Item>(sorters: Array<ArraySorter<Item>>, descending?: boolean): Sorter<Item>;
+/**
+ * Initialize a sort handler with a sorter _(and an optional default direction)_
+ * @param sorter Sorter to use for sorting
+ * @param descending Sort in descending order? _(defaults to `false`; overridden by individual sorters)_
+ * @returns Sort handler
+ */
+declare function initializeSort<Item>(sorter: ArraySorter<Item>, descending?: boolean): Sorter<Item>;
+/**
+ * Initialize a sort handler _(with an optional default direction)_
+ * @param descending Sort in descending order? _(defaults to `false`)_
+ * @returns Sort handler
+ */
+declare function initializeSort<Item>(descending?: boolean): Sorter<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
+ */
+declare function sort<Item>(array: Item[], sorters: Array<ArraySorter<Item>>, descending?: boolean): Item[];
+/**
+ * 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 individual sorters)_
+ * @returns Sorted array
+ */
+declare function sort<Item>(array: Item[], sorter: ArraySorter<Item>, descending?: boolean): Item[];
+/**
+ * Sort an array of items
+ * @param array Array to sort
+ * @param descending Sort in descending order? _(defaults to `false`)_
+ * @returns Sorted array
+ */
+declare function sort<Item>(array: Item[], descending?: boolean): Item[];
+declare namespace sort {
+  var initialize: typeof initializeSort;
+}
+declare const SORT_DIRECTION_ASCENDING: SortDirection;
+declare const SORT_DIRECTION_DESCENDING: SortDirection;
+//#endregion
 //#region src/array/swap.d.ts
 /**
  * Swap two smaller arrays within a larger array
@@ -4327,4 +4351,4 @@ declare class SizedSet<Value = unknown> extends Set<Value> {
   get(value: Value, update?: boolean): Value | undefined;
 }
 //#endregion
-export { AnyResult, ArrayComparisonSorter, ArrayKeySorter, ArrayOrPlainObject, ArrayPosition, ArrayValueSorter, Asserter, AttemptFlow, AttemptFlowPromise, type Beacon, type BeaconOptions, BuiltIns, CancelableCallback, CancelablePromise, type Color, Constructor, DiffOptions, DiffResult, DiffValue, EqualOptions, Err, EventPosition, ExtendedErr, ExtendedResult, Flow, FlowPromise, FulfilledPromise, GenericAsyncCallback, GenericCallback, type HSLAColor, type HSLColor, HasValue, Key, KeyedValue, type Logger, type Memoized, type MemoizedOptions, MergeOptions, Merger, NestedArray, NestedKeys, NestedPartial, NestedValue, NestedValues, NumericalKeys, NumericalValues, type Observable, type Observer, Ok, OnceAsyncCallback, OnceCallback, PROMISE_ABORT_EVENT, PROMISE_ABORT_OPTIONS, PROMISE_ERROR_NAME, PROMISE_MESSAGE_EXPECTATION_ATTEMPT, PROMISE_MESSAGE_EXPECTATION_RESULT, PROMISE_MESSAGE_EXPECTATION_TIMED, PROMISE_MESSAGE_TIMEOUT, PROMISE_STRATEGY_ALL, PROMISE_STRATEGY_DEFAULT, PROMISE_TYPE_FULFILLED, PROMISE_TYPE_REJECTED, PlainObject, Primitive, PromiseData, PromiseHandlers, PromiseOptions, PromiseParameters, PromiseStrategy, PromiseTimeoutError, PromisesItems, PromisesOptions, PromisesResult, PromisesUnwrapped, PromisesValue, PromisesValues, type Queue, QueueError, type QueueOptions, type Queued, type RGBAColor, type RGBColor, RejectedPromise, RequiredKeys, Result, ResultMatch, RetryError, RetryOptions, SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, Simplify, SizedMap, SizedSet, Smushed, SortDirection, type Subscription, TemplateOptions, type Time, ToString, TypedArray, Unsmushed, UnwrapValue, assert, attempt, attemptFlow, attemptPipe, 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, fromQuery, toPromise as fromResult, toPromise, getArray, getArrayPosition, getColor, getError, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getNormalizedHex, getNumber, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getString, getTimedPromise, getUuid, getValue, groupBy, handleResult, 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, matchResult, 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, settlePromise, shuffle, slice, smush, snakeCase, sort, splice, startsWith, startsWithArray, sum, swap, take, template, throttle, timed, times, titleCase, toMap, toQuery, toRecord, toResult, toSet, toggle, trim, truncate, tryDecode, tryEncode, union, unique, unsmush, unwrap, update, upperCase, words };
+export { AnyResult, ArrayComparisonSorter, ArrayKeySorter, ArrayOrPlainObject, ArrayPosition, ArrayValueSorter, Asserter, AttemptFlow, AttemptFlowPromise, type Beacon, type BeaconOptions, BuiltIns, CancelableCallback, CancelablePromise, type Color, Constructor, DiffOptions, DiffResult, DiffValue, EqualOptions, Err, EventPosition, ExtendedErr, ExtendedResult, Flow, FlowPromise, FulfilledPromise, GenericAsyncCallback, GenericCallback, type HSLAColor, type HSLColor, HasValue, Key, KeyedValue, type Logger, type Memoized, type MemoizedOptions, MergeOptions, Merger, NestedArray, NestedKeys, NestedPartial, NestedValue, NestedValues, NumericalKeys, NumericalValues, type Observable, type Observer, Ok, OnceAsyncCallback, OnceCallback, PROMISE_ABORT_EVENT, PROMISE_ABORT_OPTIONS, PROMISE_ERROR_NAME, PROMISE_MESSAGE_EXPECTATION_ATTEMPT, PROMISE_MESSAGE_EXPECTATION_RESULT, PROMISE_MESSAGE_EXPECTATION_TIMED, PROMISE_MESSAGE_TIMEOUT, PROMISE_STRATEGY_ALL, PROMISE_STRATEGY_DEFAULT, PROMISE_TYPE_FULFILLED, PROMISE_TYPE_REJECTED, PlainObject, Primitive, PromiseData, PromiseHandlers, PromiseOptions, PromiseParameters, PromiseStrategy, PromiseTimeoutError, PromisesItems, PromisesOptions, PromisesResult, PromisesUnwrapped, PromisesValue, PromisesValues, type Queue, QueueError, type QueueOptions, type Queued, type RGBAColor, type RGBColor, RejectedPromise, RequiredKeys, Result, ResultMatch, RetryError, RetryOptions, SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, Simplify, SizedMap, SizedSet, Smushed, SortDirection, Sorter, type Subscription, TemplateOptions, type Time, ToString, TypedArray, Unsmushed, UnwrapValue, assert, attempt, attemptFlow, attemptPipe, 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, fromQuery, toPromise as fromResult, toPromise, getArray, getArrayPosition, getColor, getError, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getNormalizedHex, getNumber, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getString, getTimedPromise, getUuid, getValue, groupBy, handleResult, 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, matchResult, 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, settlePromise, shuffle, slice, smush, snakeCase, sort, splice, startsWith, startsWithArray, sum, swap, take, template, throttle, timed, times, titleCase, toMap, toQuery, toRecord, toResult, toSet, toggle, trim, truncate, tryDecode, tryEncode, union, unique, unsmush, unwrap, update, upperCase, words };

package/dist/index.mjs

@@ -538,6 +538,146 @@ function take(array, first, second) {
 const EXTRACT_DROP = "drop";
 const EXTRACT_TAKE = "take";
 //#endregion
+//#region src/array/splice.ts
+function splice(array, start, deleteCountOrItems, items) {
+	return insertValues(INSERT_TYPE_SPLICE, array, typeof deleteCountOrItems === "number" ? items : deleteCountOrItems, start, typeof deleteCountOrItems === "number" ? deleteCountOrItems : 0);
+}
+//#endregion
+//#region src/array/to-set.ts
+function toSet(array, value) {
+	if (!Array.isArray(array)) return /* @__PURE__ */ new Set();
+	const callbacks = getArrayCallbacks(void 0, void 0, value);
+	if (callbacks?.value == null) return new Set(array);
+	const { length } = array;
+	const set = /* @__PURE__ */ new Set();
+	for (let index = 0; index < length; index += 1) set.add(callbacks.value(array[index], index, array));
+	return set;
+}
+//#endregion
+//#region src/internal/array/update.ts
+function updateInArray(array, items, key, replace) {
+	if (!Array.isArray(array)) return [];
+	const itemsIsArray = Array.isArray(items);
+	if (array.length === 0 || !itemsIsArray) {
+		if (itemsIsArray) array.push(...items);
+		return array;
+	}
+	const { length } = items;
+	if (length === 0) return array;
+	const callback = getArrayCallback(key);
+	for (let valuesIndex = 0; valuesIndex < length; valuesIndex += 1) {
+		const item = items[valuesIndex];
+		const value = callback?.(item) ?? item;
+		const arrayIndex = callback == null ? array.indexOf(value) : array.findIndex((arrayItem, arrayIndex) => callback(arrayItem, arrayIndex, array) === value);
+		if (arrayIndex === -1) array.push(item);
+		else if (replace) array[arrayIndex] = item;
+		else array.splice(arrayIndex, 1);
+	}
+	return array;
+}
+//#endregion
+//#region src/array/toggle.ts
+function toggle(array, values, key) {
+	return updateInArray(array, values, key, false);
+}
+//#endregion
+//#region src/array/union.ts
+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);
+}
+//#endregion
+//#region src/internal/array/overlap.ts
+function arraysOverlap(first, second) {
+	const firstArray = first.index < second.index ? first.array : second.array;
+	const secondArray = first.index < second.index ? second.array : first.array;
+	const firstIndex = firstArray === first.array ? first.index : second.index;
+	const secondIndex = firstArray === first.array ? second.index : first.index;
+	const firstEnd = firstIndex + firstArray.length - 1;
+	return {
+		overlap: firstIndex <= secondIndex + secondArray.length - 1 && firstEnd >= secondIndex,
+		first: {
+			array: firstArray,
+			index: firstIndex
+		},
+		second: {
+			array: secondArray,
+			index: secondIndex
+		}
+	};
+}
+//#endregion
+//#region src/array/move.ts
+function move(array, from, to, key) {
+	if (!Array.isArray(array)) return [];
+	const firstArray = Array.isArray(from) ? from : [from];
+	const secondArray = Array.isArray(to) ? to : [to];
+	if (firstArray.length === 0 || secondArray.length === 0) return array;
+	const firstPosition = indexOfArray(array, firstArray, key);
+	const secondPosition = indexOfArray(array, secondArray, key);
+	if (firstPosition === -1 || secondPosition === -1 || firstPosition === secondPosition) return array;
+	const { overlap } = arraysOverlap({
+		array: firstArray,
+		index: firstPosition
+	}, {
+		array: secondArray,
+		index: secondPosition
+	});
+	if (overlap) return array;
+	array.splice(firstPosition, firstArray.length);
+	const next = secondPosition < firstPosition ? secondPosition : secondPosition + secondArray.length - firstArray.length;
+	if (next >= array.length) array.push(...firstArray);
+	else array.splice(next, 0, ...firstArray);
+	return array;
+}
+move.indices = moveIndices;
+move.toIndex = moveToIndex;
+/**
+* Move an item from one index to another within an array
+*
+* If the from index is out of bounds, the array will be returned unchanged
+* @param array Array to move within
+* @param from Index to move from
+* @param to Index to move to
+* @returns Original array with item moved _(or unchanged if unable to move)_
+*/
+function moveIndices(array, from, to) {
+	if (!Array.isArray(array)) return [];
+	const { length } = array;
+	if (length === 0 || typeof from !== "number" || typeof to !== "number") return array;
+	const fromIndex = from < 0 ? length + from : from;
+	const toIndex = to < 0 ? length + to : to;
+	if (fromIndex === toIndex || fromIndex >= length || toIndex >= length) return array;
+	const spliced = array.splice(fromIndex, 1);
+	if (toIndex >= array.length) array.push(...spliced);
+	else array.splice(toIndex, 0, ...spliced);
+	return array;
+}
+function moveToIndex(array, value, index, key) {
+	if (!Array.isArray(array)) return [];
+	const { length } = array;
+	if (length === 0 || typeof index !== "number") return array;
+	const next = index < 0 ? length + index : index;
+	if (next >= length) return array;
+	const values = Array.isArray(value) ? value : [value];
+	const position = indexOfArray(array, values, key);
+	if (position === -1 || position === next) return array;
+	array.splice(position, values.length);
+	if (next >= array.length) array.push(...values);
+	else array.splice(next, 0, ...values);
+	return array;
+}
+//#endregion
 //#region src/internal/math/aggregate.ts
 function aggregate(type, array, key) {
 	const length = Array.isArray(array) ? array.length : 0;
@@ -770,6 +910,9 @@ function getComparisonSorter(callback, modifier) {
 		identifier: String(callback)
 	};
 }
+function getModifier(first, second) {
+	return modifiers[first === true || second === true ? SORT_DIRECTION_DESCENDING : SORT_DIRECTION_ASCENDING];
+}
 function getObjectSorter(obj, modifier) {
 	let sorter;
 	if (typeof obj.comparison === "function") sorter = getComparisonSorter(obj.comparison, modifier);
@@ -788,6 +931,17 @@ function getSorter(value, modifier) {
 		default: break;
 	}
 }
+function getSorters(value, modifier) {
+	const array = Array.isArray(value) ? value : [value];
+	const { length } = array;
+	const sorters = [];
+	for (let index = 0; index < length; index += 1) {
+		const item = array[index];
+		const sorter = getSorter(item, modifier);
+		if (sorter != null) sorters.push(sorter);
+	}
+	return sorters.filter((value, index, array) => array.findIndex((next) => next.identifier === value.identifier) === index);
+}
 function getValueSorter(value, modifier) {
 	return {
 		modifier,
@@ -796,32 +950,31 @@ function getValueSorter(value, modifier) {
 		value: typeof value === "function" ? value : (item) => item[value]
 	};
 }
+function initializeSort(first, second) {
+	const modifier = getModifier(first, second);
+	const sorters = getSorters(first, modifier);
+	return (array) => work$1(array, sorters, modifier);
+}
 function sort(array, first, second) {
+	const modifier = getModifier(first, second);
+	return work$1(array, getSorters(first, modifier), modifier);
+}
+function work$1(array, sorters, modifier) {
 	if (!Array.isArray(array)) return [];
 	if (array.length < 2) return array;
-	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((first, second) => compare(first, second) * modifier);
-	if (length === 1) {
-		const sorter = sorters[0];
-		return array.sort((firstItem, secondItem) => {
-			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) => {
+	return array.sort((first, second) => {
 		for (let index = 0; index < length; index += 1) {
 			const sorter = sorters[index];
-			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;
+			const values = [sorter.get ? sorter.value(first) : first, sorter.get ? sorter.value(second) : second];
+			const comparison = (sorter.compare?.complex?.(first, values[0], second, values[1]) ?? sorter.compare?.simple?.(values[0], values[1]) ?? compare(values[0], values[1])) * sorter.modifier;
 			if (comparison !== 0) return comparison;
 		}
 		return 0;
 	});
 }
+sort.initialize = initializeSort;
 const SORT_DIRECTION_ASCENDING = "ascending";
 const SORT_DIRECTION_DESCENDING = "descending";
 const modifiers = {
@@ -829,146 +982,6 @@ const modifiers = {
 	[SORT_DIRECTION_DESCENDING]: -1
 };
 //#endregion
-//#region src/array/splice.ts
-function splice(array, start, deleteCountOrItems, items) {
-	return insertValues(INSERT_TYPE_SPLICE, array, typeof deleteCountOrItems === "number" ? items : deleteCountOrItems, start, typeof deleteCountOrItems === "number" ? deleteCountOrItems : 0);
-}
-//#endregion
-//#region src/array/to-set.ts
-function toSet(array, value) {
-	if (!Array.isArray(array)) return /* @__PURE__ */ new Set();
-	const callbacks = getArrayCallbacks(void 0, void 0, value);
-	if (callbacks?.value == null) return new Set(array);
-	const { length } = array;
-	const set = /* @__PURE__ */ new Set();
-	for (let index = 0; index < length; index += 1) set.add(callbacks.value(array[index], index, array));
-	return set;
-}
-//#endregion
-//#region src/internal/array/update.ts
-function updateInArray(array, items, key, replace) {
-	if (!Array.isArray(array)) return [];
-	const itemsIsArray = Array.isArray(items);
-	if (array.length === 0 || !itemsIsArray) {
-		if (itemsIsArray) array.push(...items);
-		return array;
-	}
-	const { length } = items;
-	if (length === 0) return array;
-	const callback = getArrayCallback(key);
-	for (let valuesIndex = 0; valuesIndex < length; valuesIndex += 1) {
-		const item = items[valuesIndex];
-		const value = callback?.(item) ?? item;
-		const arrayIndex = callback == null ? array.indexOf(value) : array.findIndex((arrayItem, arrayIndex) => callback(arrayItem, arrayIndex, array) === value);
-		if (arrayIndex === -1) array.push(item);
-		else if (replace) array[arrayIndex] = item;
-		else array.splice(arrayIndex, 1);
-	}
-	return array;
-}
-//#endregion
-//#region src/array/toggle.ts
-function toggle(array, values, key) {
-	return updateInArray(array, values, key, false);
-}
-//#endregion
-//#region src/array/union.ts
-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);
-}
-//#endregion
-//#region src/internal/array/overlap.ts
-function arraysOverlap(first, second) {
-	const firstArray = first.index < second.index ? first.array : second.array;
-	const secondArray = first.index < second.index ? second.array : first.array;
-	const firstIndex = firstArray === first.array ? first.index : second.index;
-	const secondIndex = firstArray === first.array ? second.index : first.index;
-	const firstEnd = firstIndex + firstArray.length - 1;
-	return {
-		overlap: firstIndex <= secondIndex + secondArray.length - 1 && firstEnd >= secondIndex,
-		first: {
-			array: firstArray,
-			index: firstIndex
-		},
-		second: {
-			array: secondArray,
-			index: secondIndex
-		}
-	};
-}
-//#endregion
-//#region src/array/move.ts
-function move(array, from, to, key) {
-	if (!Array.isArray(array)) return [];
-	const firstArray = Array.isArray(from) ? from : [from];
-	const secondArray = Array.isArray(to) ? to : [to];
-	if (firstArray.length === 0 || secondArray.length === 0) return array;
-	const firstPosition = indexOfArray(array, firstArray, key);
-	const secondPosition = indexOfArray(array, secondArray, key);
-	if (firstPosition === -1 || secondPosition === -1 || firstPosition === secondPosition) return array;
-	const { overlap } = arraysOverlap({
-		array: firstArray,
-		index: firstPosition
-	}, {
-		array: secondArray,
-		index: secondPosition
-	});
-	if (overlap) return array;
-	array.splice(firstPosition, firstArray.length);
-	const next = secondPosition < firstPosition ? secondPosition : secondPosition + secondArray.length - firstArray.length;
-	if (next >= array.length) array.push(...firstArray);
-	else array.splice(next, 0, ...firstArray);
-	return array;
-}
-move.indices = moveIndices;
-move.toIndex = moveToIndex;
-/**
-* Move an item from one index to another within an array
-*
-* If the from index is out of bounds, the array will be returned unchanged
-* @param array Array to move within
-* @param from Index to move from
-* @param to Index to move to
-* @returns Original array with item moved _(or unchanged if unable to move)_
-*/
-function moveIndices(array, from, to) {
-	if (!Array.isArray(array)) return [];
-	const { length } = array;
-	if (length === 0 || typeof from !== "number" || typeof to !== "number") return array;
-	const fromIndex = from < 0 ? length + from : from;
-	const toIndex = to < 0 ? length + to : to;
-	if (fromIndex === toIndex || fromIndex >= length || toIndex >= length) return array;
-	const spliced = array.splice(fromIndex, 1);
-	if (toIndex >= array.length) array.push(...spliced);
-	else array.splice(toIndex, 0, ...spliced);
-	return array;
-}
-function moveToIndex(array, value, index, key) {
-	if (!Array.isArray(array)) return [];
-	const { length } = array;
-	if (length === 0 || typeof index !== "number") return array;
-	const next = index < 0 ? length + index : index;
-	if (next >= length) return array;
-	const values = Array.isArray(value) ? value : [value];
-	const position = indexOfArray(array, values, key);
-	if (position === -1 || position === next) return array;
-	array.splice(position, values.length);
-	if (next >= array.length) array.push(...values);
-	else array.splice(next, 0, ...values);
-	return array;
-}
-//#endregion
 //#region src/array/swap.ts
 function swap(array, first, second, third) {
 	if (!Array.isArray(array)) return [];

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oscarpalmer/atoms",
-	"version": "0.167.0",
+	"version": "0.168.0",
 	"description": "Atomic utilities for making your JavaScript better.",
 	"keywords": [
 		"helper",
@@ -44,6 +44,10 @@
 			"types": "./dist/array/move.d.mts",
 			"default": "./dist/array/move.mjs"
 		},
+		"./array/sort": {
+			"types": "./dist/array/sort.d.mts",
+			"default": "./dist/array/sort.mjs"
+		},
 		"./array/swap": {
 			"types": "./dist/array/swap.d.mts",
 			"default": "./dist/array/swap.mjs"

package/src/array/index.ts

@@ -16,7 +16,6 @@ export * from './position';
 export * from './push';
 export * from './select';
 export * from './slice';
-export * from './sort';
 export * from './splice';
 export * from './to-set';
 export * from './toggle';

package/src/array/sort.ts

@@ -43,6 +43,18 @@ type ArrayKeySorters<Item extends PlainObject> = {
 	[ItemKey in keyof Item]: ArrayKeySorter<Item, ItemKey>;
 }[keyof Item];
 
+/**
+ * Sorter to use for sorting
+ */
+type ArraySorter<Item> = Item extends PlainObject
+	?
+			| keyof Item
+			| ArrayComparisonSorter<Item>
+			| ArrayKeySorters<Item>
+			| ArrayValueSorter<Item>
+			| ComparisonSorter<Item>
+	: ArrayComparisonSorter<Item> | ArrayValueSorter<Item> | ComparisonSorter<Item>;
+
 /**
  * Sorting information for arrays _(using a value callback and built-in comparison)_
  */
@@ -74,41 +86,25 @@ type CompareCallbackValue<Item> = Item extends Primitive ? Item : unknown;
  */
 type ComparisonSorter<Item> = (first: Item, second: Item) => number;
 
-/**
- * Internal sorter information
- */
 type InternalSorter = {
-	compare?: SorterCompare;
+	compare?: InternalSorterCompare;
 	get: boolean;
 	identifier: string;
 	modifier: number;
-	value?: (item: PlainObject) => unknown;
+	value?: Function;
 };
 
-/**
- * Direction to sort by
- */
-export type SortDirection = 'ascending' | 'descending';
-
-/**
- * Comparison callbacks for sorter
- */
-type SorterCompare = {
+type InternalSorterCompare = {
 	complex?: Function;
 	simple?: Function;
 };
 
 /**
- * Sorter to use for sorting
+ * Direction to sort by
  */
-type Sorter<Item> = Item extends PlainObject
-	?
-			| keyof Item
-			| ArrayComparisonSorter<Item>
-			| ArrayKeySorters<Item>
-			| ArrayValueSorter<Item>
-			| ComparisonSorter<Item>
-	: ArrayComparisonSorter<Item> | ArrayValueSorter<Item> | ComparisonSorter<Item>;
+export type SortDirection = 'ascending' | 'descending';
+
+export type Sorter<Item> = (array: Item[]) => Item[];
 
 // #endregion
 
@@ -125,6 +121,13 @@ function getComparisonSorter(callback: Function, modifier: number): InternalSort
 	};
 }
 
+function getModifier(first: unknown, second: unknown): number {
+	const direction =
+		first === true || second === true ? SORT_DIRECTION_DESCENDING : SORT_DIRECTION_ASCENDING;
+
+	return modifiers[direction];
+}
+
 function getObjectSorter(obj: PlainObject, modifier: number): InternalSorter | undefined {
 	let sorter: InternalSorter | undefined;
 
@@ -165,18 +168,70 @@ function getSorter(value: unknown, modifier: number): InternalSorter | undefined
 	}
 }
 
+function getSorters(value: unknown, modifier: number): InternalSorter[] {
+	const array = Array.isArray(value) ? value : [value];
+	const {length} = array;
+
+	const sorters: InternalSorter[] = [];
+
+	for (let index = 0; index < length; index += 1) {
+		const item = array[index];
+
+		const sorter = getSorter(item, modifier);
+
+		if (sorter != null) {
+			sorters.push(sorter);
+		}
+	}
+
+	return sorters.filter(
+		(value, index, array) =>
+			array.findIndex(next => next.identifier === value.identifier) === index,
+	);
+}
+
 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],
+		value: typeof value === 'function' ? value : (item: unknown) => (item as PlainObject)[value],
 	};
 }
 
+/**
+ * Initialize a sort handler with sorters _(and an optional default direction)_
+ * @param sorters Sorters to use for sorting
+ * @param descending Sort in descending order? _(defaults to `false`; overridden by individual sorters)_
+ * @returns Sort handler
+ */
+function initializeSort<Item>(
+	sorters: Array<ArraySorter<Item>>,
+	descending?: boolean,
+): Sorter<Item>;
+
+/**
+ * Initialize a sort handler with a sorter _(and an optional default direction)_
+ * @param sorter Sorter to use for sorting
+ * @param descending Sort in descending order? _(defaults to `false`; overridden by individual sorters)_
+ * @returns Sort handler
+ */
+function initializeSort<Item>(sorter: ArraySorter<Item>, descending?: boolean): Sorter<Item>;
+
+/**
+ * Initialize a sort handler _(with an optional default direction)_
+ * @param descending Sort in descending order? _(defaults to `false`)_
+ * @returns Sort handler
+ */
+function initializeSort<Item>(descending?: boolean): Sorter<Item>;
+
+function initializeSort(first?: unknown, second?: unknown): Sorter<unknown> {
+	const modifier = getModifier(first, second);
+	const sorters = getSorters(first, modifier);
+
+	return array => work(array, sorters, modifier);
+}
+
 /**
  * Sort an array of items, using multiple sorters to sort by specific values
  * @param array Array to sort
@@ -186,7 +241,7 @@ function getValueSorter(value: string | Function, modifier: number): InternalSor
  */
 export function sort<Item>(
 	array: Item[],
-	sorters: Array<Sorter<Item>>,
+	sorters: Array<ArraySorter<Item>>,
 	descending?: boolean,
 ): Item[];
 
@@ -197,7 +252,7 @@ export function sort<Item>(
  * @param descending Sort in descending order? _(defaults to `false`; overridden by individual sorters)_
  * @returns Sorted array
  */
-export function sort<Item>(array: Item[], sorter: Sorter<Item>, descending?: boolean): Item[];
+export function sort<Item>(array: Item[], sorter: ArraySorter<Item>, descending?: boolean): Item[];
 
 /**
  * Sort an array of items
@@ -208,6 +263,12 @@ export function sort<Item>(array: Item[], sorter: Sorter<Item>, descending?: boo
 export function sort<Item>(array: Item[], descending?: boolean): Item[];
 
 export function sort(array: unknown[], first?: unknown, second?: unknown): unknown[] {
+	const modifier = getModifier(first, second);
+
+	return work(array, getSorters(first, modifier), modifier);
+}
+
+function work(array: unknown[], sorters: InternalSorter[], modifier: number): unknown[] {
 	if (!Array.isArray(array)) {
 		return [];
 	}
@@ -216,51 +277,25 @@ export function sort(array: unknown[], first?: unknown, second?: unknown): unkno
 		return array;
 	}
 
-	const direction =
-		first === true || second === true ? SORT_DIRECTION_DESCENDING : SORT_DIRECTION_ASCENDING;
-
-	const modifier = modifiers[direction];
-
-	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((first, second) => compare(first, second) * modifier);
 	}
 
-	if (length === 1) {
-		const sorter = sorters[0];
-
-		return array.sort((firstItem, secondItem) => {
-			const firstValue = sorter.get ? sorter.value!(firstItem as PlainObject) : firstItem;
-			const secondValue = sorter.get ? sorter.value!(secondItem as PlainObject) : secondItem;
-
-			return (
-				(sorter.compare?.complex?.(firstItem, firstValue, secondItem, secondValue) ??
-					sorter.compare?.simple?.(firstItem, secondItem) ??
-					compare(firstValue, secondValue)) * sorter.modifier
-			);
-		});
-	}
-
-	return array.sort((firstItem, secondItem) => {
+	return array.sort((first, second) => {
 		for (let index = 0; index < length; index += 1) {
 			const sorter = sorters[index];
 
-			const firstValue = sorter.value?.(firstItem as PlainObject) ?? firstItem;
-			const secondValue = sorter.value?.(secondItem as PlainObject) ?? secondItem;
+			const values = [
+				sorter.get ? sorter.value!(first as PlainObject) : first,
+				sorter.get ? sorter.value!(second as PlainObject) : second,
+			];
 
 			const comparison =
-				(sorter.compare?.complex?.(firstItem, firstValue, secondItem, secondValue) ??
-					sorter.compare?.simple?.(firstItem, secondItem) ??
-					compare(firstValue, secondValue)) * sorter.modifier;
+				(sorter.compare?.complex?.(first, values[0], second, values[1]) ??
+					sorter.compare?.simple?.(values[0], values[1]) ??
+					compare(values[0], values[1])) * sorter.modifier;
 
 			if (comparison !== 0) {
 				return comparison;
@@ -271,6 +306,8 @@ export function sort(array: unknown[], first?: unknown, second?: unknown): unkno
 	});
 }
 
+sort.initialize = initializeSort;
+
 // #endregion
 
 // #region Variables

package/src/index.ts

@@ -2,6 +2,7 @@ export * from './array/filter';
 export * from './array/group-by';
 export * from './array/index';
 export * from './array/move';
+export * from './array/sort';
 export * from './array/swap';
 export * from './array/to-map';
 export * from './array/to-record';