@oscarpalmer/atoms 0.166.3 → 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 = {