@oscarpalmer/atoms 0.200.0 → 0.201.0

package/dist/array/index.d.mts

@@ -14,7 +14,7 @@ import { intersection } from "./intersection.mjs";
 import { partition } from "./partition.mjs";
 import { push } from "./push.mjs";
 import { reverse } from "./reverse.mjs";
-import { select } from "./select.mjs";
+import { reverseSelect, select } from "./select.mjs";
 import { single } from "./single.mjs";
 import { drop, slice, take } from "./slice.mjs";
 import { splice } from "./splice.mjs";
@@ -23,4 +23,4 @@ import { toggle } from "./toggle.mjs";
 import { union } from "./union.mjs";
 import { unique } from "./unique.mjs";
 import { update } from "./update.mjs";
-export { ArrayComparison, chunk, compact, difference, drop, endsWithArray, exists, find, findLast, flatten, getArray, getArrayComparison, includesArray, indexOf, indexOfArray, insert, intersection, lastIndexOf, partition, push, range, reverse, select, shuffle, single, slice, splice, startsWithArray, take, times, toSet, toggle, union, unique, update };
+export { ArrayComparison, chunk, compact, difference, drop, endsWithArray, exists, find, findLast, flatten, getArray, getArrayComparison, includesArray, indexOf, indexOfArray, insert, intersection, lastIndexOf, partition, push, range, reverse, reverseSelect, select, shuffle, single, slice, splice, startsWithArray, take, times, toSet, toggle, union, unique, update };

package/dist/array/index.mjs

@@ -14,7 +14,7 @@ import { intersection } from "./intersection.mjs";
 import { partition } from "./partition.mjs";
 import { push } from "./push.mjs";
 import { reverse } from "./reverse.mjs";
-import { select } from "./select.mjs";
+import { reverseSelect, select } from "./select.mjs";
 import { single } from "./single.mjs";
 import { drop, slice, take } from "./slice.mjs";
 import { splice } from "./splice.mjs";
@@ -23,4 +23,4 @@ import { toggle } from "./toggle.mjs";
 import { union } from "./union.mjs";
 import { unique } from "./unique.mjs";
 import { update } from "./update.mjs";
-export { chunk, compact, difference, drop, endsWithArray, exists, find, findLast, flatten, getArray, getArrayComparison, includesArray, indexOf, indexOfArray, insert, intersection, lastIndexOf, partition, push, range, reverse, select, shuffle, single, slice, splice, startsWithArray, take, times, toSet, toggle, union, unique, update };
+export { chunk, compact, difference, drop, endsWithArray, exists, find, findLast, flatten, getArray, getArrayComparison, includesArray, indexOf, indexOfArray, insert, intersection, lastIndexOf, partition, push, range, reverse, reverseSelect, select, shuffle, single, slice, splice, startsWithArray, take, times, toSet, toggle, union, unique, update };

package/dist/array/select.d.mts

@@ -1,109 +1,111 @@
 import { PlainObject } from "../models.mjs";
 //#region src/array/select.d.ts
+type MapKeyOrCallback<Item> = ((item: Item, index: number, array: Item[]) => unknown) | (Item extends PlainObject ? keyof Item : never);
+type Mapped<Item, Map extends MapKeyOrCallback<Item>> = Map extends ((item: Item, index: number, array: Item[]) => unknown) ? ReturnType<Map> : Map extends keyof Item ? Item[Map] : never;
+type ObjectKeysOf<Item> = { [Key in keyof Item]: Item[Key] extends PlainObject ? Key : never; }[keyof Item];
 /**
- * Get a filtered and mapped array of items
+ * Get a mapped and filtered array of items
  *
  * @param array Array to search in
- * @param filterCallback Callback to get an item's value for matching
+ * @param map Callback or key to map the items
+ * @param filterCallback Callback to get a mapped value's value for matching
  * @param filterValue Value to match against
- * @param mapCallback Callback to map the matched items
- * @returns Filtered and mapped array of items
+ * @returns Mapped and filtered array of items
  *
  * @example
  * ```typescript
- * select(
+ * reverseSelect(
  *   [{id: 1, name: 'Alice'}, {id: 2, name: 'Bob'}, {id: 3, name: 'Charlie'}],
- *   item => item.id,
- *   2,
  *   item => item.name,
+ *   value => value.length,
+ *   3,
  * ); // => ['Bob']
  * ```
  */
-declare function select<Item, FilterCallback extends (item: Item, index: number, array: Item[]) => unknown, MapCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], filterCallback: FilterCallback, filterValue: ReturnType<FilterCallback>, mapCallback: MapCallback): Array<ReturnType<MapCallback>>;
+declare function reverseSelect<Item, Map extends MapKeyOrCallback<Item>, FilterCallback extends (item: Mapped<Item, Map>, index: number, array: Item[]) => unknown>(array: Item[], map: Map, filterCallback: FilterCallback, filterValue: ReturnType<FilterCallback>): Array<Mapped<Item, Map>>;
 /**
- * Get a filtered and mapped array of items
+ * Get a mapped and filtered array of items
  *
  * @param array Array to search in
- * @param filterCallback Callback to get an item's value for matching
+ * @param map Callback to map the items
+ * @param filterKey Key to get a mapped value's value for matching
  * @param filterValue Value to match against
- * @param mapKey Key to get an item's value for mapping
- * @returns Filtered and mapped array of items
+ * @returns Mapped and filtered array of items
  *
  * @example
  * ```typescript
- * select(
+ * reverseSelect(
  *   [{id: 1, name: 'Alice'}, {id: 2, name: 'Bob'}, {id: 3, name: 'Charlie'}],
- *   item => item.id,
- *   2,
- *   'name',
- * ); // => ['Bob']
+ *   item => ({label: item.name}),
+ *   'label',
+ *   'Bob',
+ * ); // => [{label: 'Bob'}]
  * ```
  */
-declare function select<Item extends PlainObject, FilterCallback extends (item: Item, index: number, array: Item[]) => unknown, MapKey extends keyof Item>(array: Item[], filterCallback: FilterCallback, filterValue: ReturnType<FilterCallback>, mapKey: MapKey): Array<Item[MapKey]>;
+declare function reverseSelect<Item, MapCallback extends (item: Item, index: number, array: Item[]) => PlainObject, ItemKey extends keyof ReturnType<MapCallback>>(array: Item[], map: MapCallback, filterKey: ItemKey, filterValue: ReturnType<MapCallback>[ItemKey]): Array<ReturnType<MapCallback>>;
 /**
- * Get a filtered and mapped array of items
+ * Get a mapped and filtered array of items
  *
  * @param array Array to search in
- * @param filterKey Key to get an item's value for matching
+ * @param map Key to map the items
+ * @param filterKey Key to get a mapped value's value for matching
  * @param filterValue Value to match against
- * @param mapCallback Callback to map the matched items
- * @returns Filtered and mapped array of items
+ * @returns Mapped and filtered array of items
  *
  * @example
  * ```typescript
- * select(
- *   [{id: 1, name: 'Alice'}, {id: 2, name: 'Bob'}, {id: 3, name: 'Charlie'}],
- *   'id',
- *   2,
- *   item => item.name,
- * ); // => ['Bob']
+ * reverseSelect(
+ *   [{meta: {tag: 'a'}}, {meta: {tag: 'b'}}],
+ *   'meta',
+ *   'tag',
+ *   'b',
+ * ); // => [{tag: 'b'}]
  * ```
  */
-declare function select<Item extends PlainObject, ItemKey extends keyof Item, MapCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], filterKey: ItemKey, filterValue: Item[ItemKey], mapCallback: MapCallback): Array<ReturnType<MapCallback>>;
+declare function reverseSelect<Item, MapKey extends ObjectKeysOf<Item>, ItemKey extends keyof Item[MapKey]>(array: Item[], map: MapKey, filterKey: ItemKey, filterValue: Item[MapKey][ItemKey]): Array<Item[MapKey]>;
 /**
- * Get a filtered and mapped array of items
+ * Get a mapped and filtered array of items
  *
  * @param array Array to search in
- * @param filterKey Key to get an item's value for matching
- * @param filterValue Value to match against
- * @param mapKey Key to get an item's value for mapping
- * @returns Filtered and mapped array of items
+ * @param map Callback or key to map the items
+ * @param filter Filter callback to match mapped values
+ * @returns Mapped and filtered array of items
  *
  * @example
  * ```typescript
- * select(
+ * reverseSelect(
  *   [{id: 1, name: 'Alice'}, {id: 2, name: 'Bob'}, {id: 3, name: 'Charlie'}],
- *   'id',
- *   2,
- *   'name',
+ *   item => item.name,
+ *   value => value.startsWith('B'),
  * ); // => ['Bob']
  * ```
  */
-declare function select<Item extends PlainObject, ItemKey extends keyof Item, MapKey extends keyof Item>(array: Item[], filterKey: ItemKey, filterValue: Item[ItemKey], mapKey: MapKey): Array<Item[MapKey]>;
+declare function reverseSelect<Item, Map extends MapKeyOrCallback<Item>>(array: Item[], map: Map, filter: (item: Mapped<Item, Map>, index: number, array: Item[]) => boolean): Array<Mapped<Item, Map>>;
 /**
- * Get a filtered and mapped array of items
+ * Get a mapped and filtered array of items
  *
  * @param array Array to search in
- * @param filterCallback Filter callback to match items
- * @param mapCallback Callback to map the matched items
- * @returns Filtered and mapped array of items
+ * @param map Callback or key to map the items
+ * @param value Mapped value to match against
+ * @returns Mapped and filtered array of items
  *
  * @example
  * ```typescript
- * select(
- *   [{id: 1, name: 'Alice'}, {id: 2, name: 'Bob'}, {id: 3, name: 'Charlie'}],
- *   item => item.id === 2,
- *   item => item.name,
- * ); // => ['Bob']
+ * reverseSelect(
+ *   [1, 2, 3, 2, 1],
+ *   value => value ** 2,
+ *   4,
+ * ); // => [4, 4]
  * ```
  */
-declare function select<Item, FilterCallback extends (item: Item, index: number, array: Item[]) => unknown, MapCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], filterCallback: FilterCallback, filterValue: ReturnType<FilterCallback>, mapCallback: MapCallback): Array<ReturnType<MapCallback>>;
+declare function reverseSelect<Item, Map extends MapKeyOrCallback<Item>>(array: Item[], map: Map, value: Mapped<Item, Map>): Array<Mapped<Item, Map>>;
 /**
  * Get a filtered and mapped array of items
  *
  * @param array Array to search in
- * @param filterCallback Filter callback to match items
- * @param mapKey Key to get an item's value for mapping
+ * @param filterCallback Callback to get an item's value for matching
+ * @param filterValue Value to match against
+ * @param map Callback or key to map the matched items
  * @returns Filtered and mapped array of items
  *
  * @example
@@ -112,35 +114,37 @@ declare function select<Item, FilterCallback extends (item: Item, index: number,
  *   [{id: 1, name: 'Alice'}, {id: 2, name: 'Bob'}, {id: 3, name: 'Charlie'}],
  *   item => item.id,
  *   2,
- *   'name'
+ *   item => item.name,
  * ); // => ['Bob']
  * ```
  */
-declare function select<Item extends PlainObject, FilterCallback extends (item: Item, index: number, array: Item[]) => unknown, MapKey extends keyof Item>(array: Item[], filterCallback: FilterCallback, filterValue: ReturnType<FilterCallback>, mapKey: MapKey): Array<Item[MapKey]>;
+declare function select<Item, FilterCallback extends (item: Item, index: number, array: Item[]) => unknown, Map extends MapKeyOrCallback<Item>>(array: Item[], filterCallback: FilterCallback, filterValue: ReturnType<FilterCallback>, map: Map): Array<Mapped<Item, Map>>;
 /**
  * Get a filtered and mapped array of items
  *
  * @param array Array to search in
- * @param filter Filter callback to match items
- * @param map Callback to map the matched items
+ * @param filterKey Key to get an item's value for matching
+ * @param filterValue Value to match against
+ * @param map Callback or key to map the matched items
  * @returns Filtered and mapped array of items
  *
  * @example
  * ```typescript
  * select(
  *   [{id: 1, name: 'Alice'}, {id: 2, name: 'Bob'}, {id: 3, name: 'Charlie'}],
- *   item => item.id === 2,
- *   item => item.name,
+ *   'id',
+ *   2,
+ *   'name',
  * ); // => ['Bob']
  * ```
  */
-declare function select<Item, MapCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], filter: (item: Item, index: number, array: Item[]) => boolean, map: MapCallback): Array<ReturnType<MapCallback>>;
+declare function select<Item extends PlainObject, ItemKey extends keyof Item, Map extends MapKeyOrCallback<Item>>(array: Item[], filterKey: ItemKey, filterValue: Item[ItemKey], map: Map): Array<Mapped<Item, Map>>;
 /**
  * Get a filtered and mapped array of items
  *
  * @param array Array to search in
  * @param filter Filter callback to match items
- * @param map Key to get an item's value for mapping
+ * @param map Callback or key to map the matched items
  * @returns Filtered and mapped array of items
  *
  * @example
@@ -148,17 +152,17 @@ declare function select<Item, MapCallback extends (item: Item, index: number, ar
  * select(
  *   [{id: 1, name: 'Alice'}, {id: 2, name: 'Bob'}, {id: 3, name: 'Charlie'}],
  *   item => item.id === 2,
- *   'name'
+ *   item => item.name,
  * ); // => ['Bob']
  * ```
  */
-declare function select<Item extends PlainObject, MapKey extends keyof Item>(array: Item[], filter: (item: Item, index: number, array: Item[]) => boolean, map: MapKey): Array<Item[MapKey]>;
+declare function select<Item, Map extends MapKeyOrCallback<Item>>(array: Item[], filter: (item: Item, index: number, array: Item[]) => boolean, map: Map): Array<Mapped<Item, Map>>;
 /**
  * Get a filtered and mapped array of items
  *
  * @param array Array to search in
  * @param item Item to match against
- * @param map Callback to map the matched items
+ * @param map Callback or key to map the matched items
  * @returns Filtered and mapped array of items
  *
  * @example
@@ -170,6 +174,9 @@ declare function select<Item extends PlainObject, MapKey extends keyof Item>(arr
  * ); // => [9]
  * ```
  */
-declare function select<Item, MapCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], item: Item, map: MapCallback): Array<ReturnType<MapCallback>>;
+declare function select<Item, Map extends MapKeyOrCallback<Item>>(array: Item[], item: Item, map: Map): Array<Mapped<Item, Map>>;
+declare namespace select {
+  var reverse: typeof reverseSelect;
+}
 //#endregion
-export { select };
+export { reverseSelect, select };

package/dist/array/select.mjs

@@ -1,8 +1,23 @@
 import { findValues } from "../internal/array/find.mjs";
 //#region src/array/select.ts
+function reverseSelect(array, ...parameters) {
+	const mapper = parameters.shift();
+	return findValues("all", array, parameters, {
+		callback: mapper,
+		reverse: true
+	}).matched;
+}
 function select(array, ...parameters) {
+	return selectValues(array, parameters);
+}
+function selectValues(array, parameters) {
 	const mapper = parameters.pop();
-	return findValues("all", array, parameters, mapper).matched;
+	return findValues("all", array, parameters, {
+		callback: mapper,
+		reverse: false
+	}).matched;
 }
+select.reverse = reverseSelect;
+Object.defineProperty(select, "reverse", { value: reverseSelect });
 //#endregion
-export { select };
+export { reverseSelect, select };

package/dist/index.d.mts

@@ -1778,110 +1778,112 @@ export declare function push<Item>(array: Item[], pushed: Item[]): number;
 export declare function reverse<Item>(array: Item[]): Item[];
 //#endregion
 //#region src/array/select.d.ts
+type MapKeyOrCallback<Item> = ((item: Item, index: number, array: Item[]) => unknown) | (Item extends PlainObject ? keyof Item : never);
+type Mapped<Item, Map extends MapKeyOrCallback<Item>> = Map extends ((item: Item, index: number, array: Item[]) => unknown) ? ReturnType<Map> : Map extends keyof Item ? Item[Map] : never;
+type ObjectKeysOf<Item> = { [Key in keyof Item]: Item[Key] extends PlainObject ? Key : never; }[keyof Item];
 /**
- * Get a filtered and mapped array of items
+ * Get a mapped and filtered array of items
  *
  * @param array Array to search in
- * @param filterCallback Callback to get an item's value for matching
+ * @param map Callback or key to map the items
+ * @param filterCallback Callback to get a mapped value's value for matching
  * @param filterValue Value to match against
- * @param mapCallback Callback to map the matched items
- * @returns Filtered and mapped array of items
+ * @returns Mapped and filtered array of items
  *
  * @example
  * ```typescript
- * select(
+ * reverseSelect(
  *   [{id: 1, name: 'Alice'}, {id: 2, name: 'Bob'}, {id: 3, name: 'Charlie'}],
- *   item => item.id,
- *   2,
  *   item => item.name,
+ *   value => value.length,
+ *   3,
  * ); // => ['Bob']
  * ```
  */
-export declare function select<Item, FilterCallback extends (item: Item, index: number, array: Item[]) => unknown, MapCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], filterCallback: FilterCallback, filterValue: ReturnType<FilterCallback>, mapCallback: MapCallback): Array<ReturnType<MapCallback>>;
+export declare function reverseSelect<Item, Map extends MapKeyOrCallback<Item>, FilterCallback extends (item: Mapped<Item, Map>, index: number, array: Item[]) => unknown>(array: Item[], map: Map, filterCallback: FilterCallback, filterValue: ReturnType<FilterCallback>): Array<Mapped<Item, Map>>;
 /**
- * Get a filtered and mapped array of items
+ * Get a mapped and filtered array of items
  *
  * @param array Array to search in
- * @param filterCallback Callback to get an item's value for matching
+ * @param map Callback to map the items
+ * @param filterKey Key to get a mapped value's value for matching
  * @param filterValue Value to match against
- * @param mapKey Key to get an item's value for mapping
- * @returns Filtered and mapped array of items
+ * @returns Mapped and filtered array of items
  *
  * @example
  * ```typescript
- * select(
+ * reverseSelect(
  *   [{id: 1, name: 'Alice'}, {id: 2, name: 'Bob'}, {id: 3, name: 'Charlie'}],
- *   item => item.id,
- *   2,
- *   'name',
- * ); // => ['Bob']
+ *   item => ({label: item.name}),
+ *   'label',
+ *   'Bob',
+ * ); // => [{label: 'Bob'}]
  * ```
  */
-export declare function select<Item extends PlainObject, FilterCallback extends (item: Item, index: number, array: Item[]) => unknown, MapKey extends keyof Item>(array: Item[], filterCallback: FilterCallback, filterValue: ReturnType<FilterCallback>, mapKey: MapKey): Array<Item[MapKey]>;
+export declare function reverseSelect<Item, MapCallback extends (item: Item, index: number, array: Item[]) => PlainObject, ItemKey extends keyof ReturnType<MapCallback>>(array: Item[], map: MapCallback, filterKey: ItemKey, filterValue: ReturnType<MapCallback>[ItemKey]): Array<ReturnType<MapCallback>>;
 /**
- * Get a filtered and mapped array of items
+ * Get a mapped and filtered array of items
  *
  * @param array Array to search in
- * @param filterKey Key to get an item's value for matching
+ * @param map Key to map the items
+ * @param filterKey Key to get a mapped value's value for matching
  * @param filterValue Value to match against
- * @param mapCallback Callback to map the matched items
- * @returns Filtered and mapped array of items
+ * @returns Mapped and filtered array of items
  *
  * @example
  * ```typescript
- * select(
- *   [{id: 1, name: 'Alice'}, {id: 2, name: 'Bob'}, {id: 3, name: 'Charlie'}],
- *   'id',
- *   2,
- *   item => item.name,
- * ); // => ['Bob']
+ * reverseSelect(
+ *   [{meta: {tag: 'a'}}, {meta: {tag: 'b'}}],
+ *   'meta',
+ *   'tag',
+ *   'b',
+ * ); // => [{tag: 'b'}]
  * ```
  */
-export declare function select<Item extends PlainObject, ItemKey extends keyof Item, MapCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], filterKey: ItemKey, filterValue: Item[ItemKey], mapCallback: MapCallback): Array<ReturnType<MapCallback>>;
+export declare function reverseSelect<Item, MapKey extends ObjectKeysOf<Item>, ItemKey extends keyof Item[MapKey]>(array: Item[], map: MapKey, filterKey: ItemKey, filterValue: Item[MapKey][ItemKey]): Array<Item[MapKey]>;
 /**
- * Get a filtered and mapped array of items
+ * Get a mapped and filtered array of items
  *
  * @param array Array to search in
- * @param filterKey Key to get an item's value for matching
- * @param filterValue Value to match against
- * @param mapKey Key to get an item's value for mapping
- * @returns Filtered and mapped array of items
+ * @param map Callback or key to map the items
+ * @param filter Filter callback to match mapped values
+ * @returns Mapped and filtered array of items
  *
  * @example
  * ```typescript
- * select(
+ * reverseSelect(
  *   [{id: 1, name: 'Alice'}, {id: 2, name: 'Bob'}, {id: 3, name: 'Charlie'}],
- *   'id',
- *   2,
- *   'name',
+ *   item => item.name,
+ *   value => value.startsWith('B'),
  * ); // => ['Bob']
  * ```
  */
-export declare function select<Item extends PlainObject, ItemKey extends keyof Item, MapKey extends keyof Item>(array: Item[], filterKey: ItemKey, filterValue: Item[ItemKey], mapKey: MapKey): Array<Item[MapKey]>;
+export declare function reverseSelect<Item, Map extends MapKeyOrCallback<Item>>(array: Item[], map: Map, filter: (item: Mapped<Item, Map>, index: number, array: Item[]) => boolean): Array<Mapped<Item, Map>>;
 /**
- * Get a filtered and mapped array of items
+ * Get a mapped and filtered array of items
  *
  * @param array Array to search in
- * @param filterCallback Filter callback to match items
- * @param mapCallback Callback to map the matched items
- * @returns Filtered and mapped array of items
+ * @param map Callback or key to map the items
+ * @param value Mapped value to match against
+ * @returns Mapped and filtered array of items
  *
  * @example
  * ```typescript
- * select(
- *   [{id: 1, name: 'Alice'}, {id: 2, name: 'Bob'}, {id: 3, name: 'Charlie'}],
- *   item => item.id === 2,
- *   item => item.name,
- * ); // => ['Bob']
+ * reverseSelect(
+ *   [1, 2, 3, 2, 1],
+ *   value => value ** 2,
+ *   4,
+ * ); // => [4, 4]
  * ```
  */
-export declare function select<Item, FilterCallback extends (item: Item, index: number, array: Item[]) => unknown, MapCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], filterCallback: FilterCallback, filterValue: ReturnType<FilterCallback>, mapCallback: MapCallback): Array<ReturnType<MapCallback>>;
+export declare function reverseSelect<Item, Map extends MapKeyOrCallback<Item>>(array: Item[], map: Map, value: Mapped<Item, Map>): Array<Mapped<Item, Map>>;
 /**
  * Get a filtered and mapped array of items
  *
  * @param array Array to search in
- * @param filterCallback Filter callback to match items
- * @param mapKey Key to get an item's value for mapping
+ * @param filterCallback Callback to get an item's value for matching
+ * @param filterValue Value to match against
+ * @param map Callback or key to map the matched items
  * @returns Filtered and mapped array of items
  *
  * @example
@@ -1890,35 +1892,37 @@ export declare function select<Item, FilterCallback extends (item: Item, index:
  *   [{id: 1, name: 'Alice'}, {id: 2, name: 'Bob'}, {id: 3, name: 'Charlie'}],
  *   item => item.id,
  *   2,
- *   'name'
+ *   item => item.name,
  * ); // => ['Bob']
  * ```
  */
-export declare function select<Item extends PlainObject, FilterCallback extends (item: Item, index: number, array: Item[]) => unknown, MapKey extends keyof Item>(array: Item[], filterCallback: FilterCallback, filterValue: ReturnType<FilterCallback>, mapKey: MapKey): Array<Item[MapKey]>;
+export declare function select<Item, FilterCallback extends (item: Item, index: number, array: Item[]) => unknown, Map extends MapKeyOrCallback<Item>>(array: Item[], filterCallback: FilterCallback, filterValue: ReturnType<FilterCallback>, map: Map): Array<Mapped<Item, Map>>;
 /**
  * Get a filtered and mapped array of items
  *
  * @param array Array to search in
- * @param filter Filter callback to match items
- * @param map Callback to map the matched items
+ * @param filterKey Key to get an item's value for matching
+ * @param filterValue Value to match against
+ * @param map Callback or key to map the matched items
  * @returns Filtered and mapped array of items
  *
  * @example
  * ```typescript
  * select(
  *   [{id: 1, name: 'Alice'}, {id: 2, name: 'Bob'}, {id: 3, name: 'Charlie'}],
- *   item => item.id === 2,
- *   item => item.name,
+ *   'id',
+ *   2,
+ *   'name',
  * ); // => ['Bob']
  * ```
  */
-export declare function select<Item, MapCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], filter: (item: Item, index: number, array: Item[]) => boolean, map: MapCallback): Array<ReturnType<MapCallback>>;
+export declare function select<Item extends PlainObject, ItemKey extends keyof Item, Map extends MapKeyOrCallback<Item>>(array: Item[], filterKey: ItemKey, filterValue: Item[ItemKey], map: Map): Array<Mapped<Item, Map>>;
 /**
  * Get a filtered and mapped array of items
  *
  * @param array Array to search in
  * @param filter Filter callback to match items
- * @param map Key to get an item's value for mapping
+ * @param map Callback or key to map the matched items
  * @returns Filtered and mapped array of items
  *
  * @example
@@ -1926,17 +1930,17 @@ export declare function select<Item, MapCallback extends (item: Item, index: num
  * select(
  *   [{id: 1, name: 'Alice'}, {id: 2, name: 'Bob'}, {id: 3, name: 'Charlie'}],
  *   item => item.id === 2,
- *   'name'
+ *   item => item.name,
  * ); // => ['Bob']
  * ```
  */
-export declare function select<Item extends PlainObject, MapKey extends keyof Item>(array: Item[], filter: (item: Item, index: number, array: Item[]) => boolean, map: MapKey): Array<Item[MapKey]>;
+export declare function select<Item, Map extends MapKeyOrCallback<Item>>(array: Item[], filter: (item: Item, index: number, array: Item[]) => boolean, map: Map): Array<Mapped<Item, Map>>;
 /**
  * Get a filtered and mapped array of items
  *
  * @param array Array to search in
  * @param item Item to match against
- * @param map Callback to map the matched items
+ * @param map Callback or key to map the matched items
  * @returns Filtered and mapped array of items
  *
  * @example
@@ -1948,7 +1952,10 @@ export declare function select<Item extends PlainObject, MapKey extends keyof It
  * ); // => [9]
  * ```
  */
-export declare function select<Item, MapCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], item: Item, map: MapCallback): Array<ReturnType<MapCallback>>;
+export declare function select<Item, Map extends MapKeyOrCallback<Item>>(array: Item[], item: Item, map: Map): Array<Mapped<Item, Map>>;
+export declare namespace select {
+  var reverse: typeof reverseSelect;
+}
 //#endregion
 //#region src/array/single.d.ts
 /**

package/dist/index.mjs

@@ -68,12 +68,16 @@ function findValues(type, array, parameters, mapper) {
 		result.matched = [...new Set(array)];
 		return result;
 	}
-	const mapCallback = getArrayCallback(mapper);
+	const mapCallback = getArrayCallback(mapper?.callback);
+	const mapReverse = mapper?.reverse ?? false;
+	const mapAfter = mapCallback == null ? void 0 : mapReverse ? void 0 : mapCallback;
+	const mapBefore = mapCallback == null ? void 0 : mapReverse ? mapCallback : void 0;
 	if (callbacks?.bool != null || type === "all" && key == null) {
 		const callback = callbacks?.bool ?? ((item) => Object.is(item, value));
 		for (let index = 0; index < length; index += 1) {
 			const item = array[index];
-			if (callback(item, index, array)) result.matched.push(mapCallback?.(item, index, array) ?? item);
+			const transformed = mapBefore?.(item, index, array) ?? item;
+			if (callback(transformed, index, array)) result.matched.push(mapAfter?.(item, index, array) ?? transformed);
 			else result.notMatched.push(item);
 		}
 		return result;
@@ -81,10 +85,18 @@ function findValues(type, array, parameters, mapper) {
 	const keys = /* @__PURE__ */ new Set();
 	for (let index = 0; index < length; index += 1) {
 		const item = array[index];
-		const keyed = callbacks?.keyed?.(item, index, array) ?? item;
+		let keyed;
+		let transformed;
+		if (mapBefore == null) {
+			keyed = callbacks?.keyed?.(item, index, array) ?? item;
+			transformed = item;
+		} else {
+			transformed = mapBefore(item, index, array);
+			keyed = callbacks?.keyed?.(transformed, index, array) ?? transformed;
+		}
 		if (type === "all" && Object.is(keyed, value) || type === "unique" && !keys.has(keyed)) {
 			keys.add(keyed);
-			result.matched.push(mapCallback?.(item, index, array) ?? item);
+			result.matched.push(mapAfter?.(item, index, array) ?? transformed);
 		} else result.notMatched.push(item);
 	}
 	return result;
@@ -661,9 +673,23 @@ function reverse(array) {
 }
 //#endregion
 //#region src/array/select.ts
+function reverseSelect(array, ...parameters) {
+	return findValues("all", array, parameters, {
+		callback: parameters.shift(),
+		reverse: true
+	}).matched;
+}
 function select(array, ...parameters) {
-	return findValues("all", array, parameters, parameters.pop()).matched;
+	return selectValues(array, parameters);
+}
+function selectValues(array, parameters) {
+	return findValues("all", array, parameters, {
+		callback: parameters.pop(),
+		reverse: false
+	}).matched;
 }
+select.reverse = reverseSelect;
+Object.defineProperty(select, "reverse", { value: reverseSelect });
 //#endregion
 //#region src/array/single.ts
 function single(array, ...parameters) {
@@ -6488,4 +6514,4 @@ var SizedSet = class extends Set {
 	}
 };
 //#endregion
-export { CancelablePromise, Logger, PromiseTimeoutError, QueueError, RetryError, SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, SizedMap, SizedSet, assert, assertCondition, assertDefined, assertInstanceOf, assertIs, assertProperty, assign, asyncAttempt, asyncDebounce, asyncFlow, asyncMatchResult, asyncOnce, asyncPipe, asyncThrottle, attempt, attemptAsyncFlow, attemptAsyncPipe, attemptFlow, attemptPipe, attemptPromise, average, beacon, between, camelCase, cancelable, capitalize, ceil, chunk, clamp, clone, compact, compare, copy, count, debounce, deburr, dedent, delay, deregisterCloner, deregisterComparator, deregisterEqualizer, diff, difference, drop, endsWith, endsWithArray, equal, error, exclude, exists, filter, find, findLast, first, firstOrDefault, flatFreeze, flatten, floor, flow, freeze, fromQuery, toPromise as fromResult, toPromise, fuzzy, fuzzyMatch, getArray, getArrayComparison, getColor, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getHwbColor, getHwbaColor, getNormalizedHex, getNumber, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloatingNumber as getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getSortedIndex, getString, getTimedPromise, getUuid, getValue, groupArraysBy, groupBy, handleResult, hasValue, hasValueResult, herald, hexToHsl, hexToHsla, hexToHwb, hexToHwba, hexToRgb, hexToRgba, hslToHex, hslToHwb, hslToHwba, hslToRgb, hslToRgba, hwbToHex, hwbToHsl, hwbToHsla, hwbToRgb, hwbToRgba, ignoreKey, inMap, inSet, includes, includesArray, indexOf, indexOfArray, initializeAssigner, initializeCloner, initializeEqualizer, initializeMerger, initializeNormalizer, initializeSorter, initializeTemplater, initializeTransformer, insert, interpolate, intersection, isArrayOrPlainObject, isBeacon, isBeaconSubscription, isColor, isConstructor, isEmpty, isError, isFrozen, isFulfilled, isHerald, isHeraldEvents, isHeraldSubscription, isHexColor, isHslColor, isHslaColor, isHwbColor, isHwbaColor, isInstanceOf, isKey, isKeyedQueue, isLogger, isNonArrayOrPlainObject, isNonConstructor, isNonEmpty, isNonInstanceOf, isNonKey, isNonNullable, isNonNullableOrEmpty, isNonNullableOrWhitespace, isNonNumber, isNonNumerical, isNonObject, isNonPlainObject, isNonPrimitive, isNonTypedArray, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isObservable, isOk, isPlainObject, isPrimitive, isQueue, isQueueInstance, isRejected, isResult, isRgbColor, isRgbaColor, isSorted, isSubscription, isSubscriptions, isTimedLogger, isTypedArray, join, kebabCase, keyedQueue, last, lastIndexOf, lastOrDefault, lowerCase, matchResult, max, median, memoize, merge, min, move, moveIndices, moveToIndex, noop, normalize, ok, omit, once, parse, partition, pascalCase, pick, pipe, promises, push, queue, range, registerCloner, registerComparator, registerEqualizer, resultPromises, retry, reverse, rgbToHex, rgbToHsl, rgbToHsla, rgbToHwb, rgbToHwba, round, select, setValue, settlePromise, shake, shuffle, single, slice, smush, snakeCase, sort, splice, startsWith, startsWithArray, subscriptions, sum, swap, take, template, throttle, timed, times, titleCase, toMap, toMapArrays, toQuery, toRecord, toRecordArrays, toResult, toSet, toggle, transform, trim, truncate, tryDecode, tryEncode, union, unique, unsmush, unwrap, update, upperCase, words };
+export { CancelablePromise, Logger, PromiseTimeoutError, QueueError, RetryError, SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, SizedMap, SizedSet, assert, assertCondition, assertDefined, assertInstanceOf, assertIs, assertProperty, assign, asyncAttempt, asyncDebounce, asyncFlow, asyncMatchResult, asyncOnce, asyncPipe, asyncThrottle, attempt, attemptAsyncFlow, attemptAsyncPipe, attemptFlow, attemptPipe, attemptPromise, average, beacon, between, camelCase, cancelable, capitalize, ceil, chunk, clamp, clone, compact, compare, copy, count, debounce, deburr, dedent, delay, deregisterCloner, deregisterComparator, deregisterEqualizer, diff, difference, drop, endsWith, endsWithArray, equal, error, exclude, exists, filter, find, findLast, first, firstOrDefault, flatFreeze, flatten, floor, flow, freeze, fromQuery, toPromise as fromResult, toPromise, fuzzy, fuzzyMatch, getArray, getArrayComparison, getColor, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getHwbColor, getHwbaColor, getNormalizedHex, getNumber, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloatingNumber as getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getSortedIndex, getString, getTimedPromise, getUuid, getValue, groupArraysBy, groupBy, handleResult, hasValue, hasValueResult, herald, hexToHsl, hexToHsla, hexToHwb, hexToHwba, hexToRgb, hexToRgba, hslToHex, hslToHwb, hslToHwba, hslToRgb, hslToRgba, hwbToHex, hwbToHsl, hwbToHsla, hwbToRgb, hwbToRgba, ignoreKey, inMap, inSet, includes, includesArray, indexOf, indexOfArray, initializeAssigner, initializeCloner, initializeEqualizer, initializeMerger, initializeNormalizer, initializeSorter, initializeTemplater, initializeTransformer, insert, interpolate, intersection, isArrayOrPlainObject, isBeacon, isBeaconSubscription, isColor, isConstructor, isEmpty, isError, isFrozen, isFulfilled, isHerald, isHeraldEvents, isHeraldSubscription, isHexColor, isHslColor, isHslaColor, isHwbColor, isHwbaColor, isInstanceOf, isKey, isKeyedQueue, isLogger, isNonArrayOrPlainObject, isNonConstructor, isNonEmpty, isNonInstanceOf, isNonKey, isNonNullable, isNonNullableOrEmpty, isNonNullableOrWhitespace, isNonNumber, isNonNumerical, isNonObject, isNonPlainObject, isNonPrimitive, isNonTypedArray, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isObservable, isOk, isPlainObject, isPrimitive, isQueue, isQueueInstance, isRejected, isResult, isRgbColor, isRgbaColor, isSorted, isSubscription, isSubscriptions, isTimedLogger, isTypedArray, join, kebabCase, keyedQueue, last, lastIndexOf, lastOrDefault, lowerCase, matchResult, max, median, memoize, merge, min, move, moveIndices, moveToIndex, noop, normalize, ok, omit, once, parse, partition, pascalCase, pick, pipe, promises, push, queue, range, registerCloner, registerComparator, registerEqualizer, resultPromises, retry, reverse, reverseSelect, rgbToHex, rgbToHsl, rgbToHsla, rgbToHwb, rgbToHwba, round, select, setValue, settlePromise, shake, shuffle, single, slice, smush, snakeCase, sort, splice, startsWith, startsWithArray, subscriptions, sum, swap, take, template, throttle, timed, times, titleCase, toMap, toMapArrays, toQuery, toRecord, toRecordArrays, toResult, toSet, toggle, transform, trim, truncate, tryDecode, tryEncode, union, unique, unsmush, unwrap, update, upperCase, words };

package/dist/internal/array/find.d.mts

@@ -1,4 +1,8 @@
 //#region src/internal/array/find.d.ts
+type FindMapper = {
+  callback: unknown;
+  reverse: boolean;
+};
 type FindValueType = 'index' | 'item';
 type FindValuesResult = {
   matched: unknown[];
@@ -14,7 +18,7 @@ declare function createFindParameters(original: unknown[]): Parameters;
 declare function findValue(type: Exclude<FindValueType, 'item'>, array: unknown[], parameters: unknown[], reversed: boolean): number;
 declare function findValue(type: Exclude<FindValueType, 'index'>, array: unknown[], parameters: unknown[], reversed: boolean): unknown;
 declare function findAbsoluteValueOrDefault(array: unknown[], parameters: unknown[], defaultValue: unknown, useDefaultValue: boolean, reversed: boolean): unknown;
-declare function findValues(type: FindValuesType, array: unknown[], parameters: unknown[], mapper?: unknown): FindValuesResult;
+declare function findValues(type: FindValuesType, array: unknown[], parameters: unknown[], mapper?: FindMapper): FindValuesResult;
 declare const FIND_VALUE_INDEX = "index";
 declare const FIND_VALUE_ITEM = "item";
 declare const FIND_VALUES_ALL: FindValuesType;

package/dist/internal/array/find.mjs

@@ -52,12 +52,16 @@ function findValues(type, array, parameters, mapper) {
 		result.matched = [...new Set(array)];
 		return result;
 	}
-	const mapCallback = getArrayCallback(mapper);
+	const mapCallback = getArrayCallback(mapper?.callback);
+	const mapReverse = mapper?.reverse ?? false;
+	const mapAfter = mapCallback == null ? void 0 : mapReverse ? void 0 : mapCallback;
+	const mapBefore = mapCallback == null ? void 0 : mapReverse ? mapCallback : void 0;
 	if (callbacks?.bool != null || type === "all" && key == null) {
 		const callback = callbacks?.bool ?? ((item) => Object.is(item, value));
 		for (let index = 0; index < length; index += 1) {
 			const item = array[index];
-			if (callback(item, index, array)) result.matched.push(mapCallback?.(item, index, array) ?? item);
+			const transformed = mapBefore?.(item, index, array) ?? item;
+			if (callback(transformed, index, array)) result.matched.push(mapAfter?.(item, index, array) ?? transformed);
 			else result.notMatched.push(item);
 		}
 		return result;
@@ -65,10 +69,18 @@ function findValues(type, array, parameters, mapper) {
 	const keys = /* @__PURE__ */ new Set();
 	for (let index = 0; index < length; index += 1) {
 		const item = array[index];
-		const keyed = callbacks?.keyed?.(item, index, array) ?? item;
+		let keyed;
+		let transformed;
+		if (mapBefore == null) {
+			keyed = callbacks?.keyed?.(item, index, array) ?? item;
+			transformed = item;
+		} else {
+			transformed = mapBefore(item, index, array);
+			keyed = callbacks?.keyed?.(transformed, index, array) ?? transformed;
+		}
 		if (type === "all" && Object.is(keyed, value) || type === "unique" && !keys.has(keyed)) {
 			keys.add(keyed);
-			result.matched.push(mapCallback?.(item, index, array) ?? item);
+			result.matched.push(mapAfter?.(item, index, array) ?? transformed);
 		} else result.notMatched.push(item);
 	}
 	return result;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oscarpalmer/atoms",
-	"version": "0.200.0",
+	"version": "0.201.0",
 	"description": "Atomic utilities for making your JavaScript better.",
 	"keywords": [
 		"array",