@zelgadis87/utils-core 5.2.2 → 5.2.4

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package",
   "name": "@zelgadis87/utils-core",
-  "version": "5.2.2",
+  "version": "5.2.4",
   "author": "Zelgadis87",
   "license": "ISC",
   "private": false,

package/src/sorting/Sorter.ts

@@ -149,7 +149,7 @@ const next = <T, R>( fns: ReadonlyArray<TComparisonFunction<T>>, transform: TFun
 			return compareNumbers( fns, transform as TFunction<T, number>, { direction: 'DESC', ...opts } );
 		},
 	} as const satisfies TSorterStepForNumbers<R, TSorter<T>>;
-	const retForStrings = {
+	const retForStringsV1 = {
 		...retAsUsing,
 		inLexographicalOrder( opts: { nullsFirst?: boolean } = {} ) {
 			return compareStrings( fns, transform as TFunction<T, string>, { direction: 'ASC', ignoreCase: false, ...opts } );
@@ -163,6 +163,22 @@ const next = <T, R>( fns: ReadonlyArray<TComparisonFunction<T>>, transform: TFun
 		inReverseLexographicalOrderIgnoringCase( opts: { nullsFirst?: boolean } = {} ) {
 			return compareStrings( fns, transform as TFunction<T, string>, { direction: 'DESC', ignoreCase: true, ...opts } );
 		},
+	} as const;
+	const retForStrings = {
+		...retAsUsing,
+		...retForStringsV1,
+		inLexicographicalOrder( opts: { nullsFirst?: boolean } = {} ) {
+			return compareStrings( fns, transform as TFunction<T, string>, { direction: 'ASC', ignoreCase: false, ...opts } );
+		},
+		inLexicographicalOrderIgnoringCase( opts: { nullsFirst?: boolean } = {} ) {
+			return compareStrings( fns, transform as TFunction<T, string>, { direction: 'ASC', ignoreCase: true, ...opts } );
+		},
+		inReverseLexicographicalOrder( opts: { nullsFirst?: boolean } = {} ) {
+			return compareStrings( fns, transform as TFunction<T, string>, { direction: 'DESC', ignoreCase: false, ...opts } );
+		},
+		inReverseLexicographicalOrderIgnoringCase( opts: { nullsFirst?: boolean } = {} ) {
+			return compareStrings( fns, transform as TFunction<T, string>, { direction: 'DESC', ignoreCase: true, ...opts } );
+		},
 	} as const satisfies TSorterStepForStrings<R, TSorter<T>>;
 	const retForBooleans = {
 		...retAsUsing,
@@ -317,10 +333,14 @@ type TSorterStepForNumbers<_T, Ret> = {
 	inDescendingOrder( opts?: { nullsFirst?: boolean } ): Ret;
 };
 type TSorterStepForStrings<_T, Ret> = {
-	inLexographicalOrder( opts?: { nullsFirst?: boolean } ): Ret;
-	inLexographicalOrderIgnoringCase( opts?: { nullsFirst?: boolean } ): Ret;
-	inReverseLexographicalOrder( opts?: { nullsFirst?: boolean } ): Ret;
-	inReverseLexographicalOrderIgnoringCase( opts?: { nullsFirst?: boolean } ): Ret;
+	/** @deprecated: Use inLexographicalOrder instead */ inLexographicalOrder( opts?: { nullsFirst?: boolean } ): Ret;
+	/** @deprecated: Use inLexographicalOrderIgnoringCase instead */ inLexographicalOrderIgnoringCase( opts?: { nullsFirst?: boolean } ): Ret;
+	/** @deprecated: Use inReverseLexographicalOrder instead */ inReverseLexographicalOrder( opts?: { nullsFirst?: boolean } ): Ret;
+	/** @deprecated: Use inReverseLexographicalOrderIgnoringCase instead */ inReverseLexographicalOrderIgnoringCase( opts?: { nullsFirst?: boolean } ): Ret;
+	inLexicographicalOrder( opts?: { nullsFirst?: boolean } ): Ret;
+	inLexicographicalOrderIgnoringCase( opts?: { nullsFirst?: boolean } ): Ret;
+	inReverseLexicographicalOrder( opts?: { nullsFirst?: boolean } ): Ret;
+	inReverseLexicographicalOrderIgnoringCase( opts?: { nullsFirst?: boolean } ): Ret;
 };
 type TSorterStepForBooleans<_T, Ret> = {
 	truesFirst( opts?: { nullsFirst?: boolean } ): Ret;

package/src/utils/arrays.ts

@@ -1,3 +1,4 @@
+import Optional, { type TOptional } from "../Optional.js";
 import type { TComparisonFunction } from "../sorting/_index.js";
 import type { TAccumulator, TBiPredicate, TPredicate, TTransformer } from "./functions.js";
 import { isNullOrUndefined, type TMaybe } from "./nulls.js";
@@ -171,3 +172,24 @@ export function shallowArrayEquals( a: unknown[], b: unknown[] ): boolean {
 	}
 	return true;
 }
+
+export function findInArray<T>( arr: T[], predicate: TPredicate<T> ): TOptional<T> {
+	return Optional.ofNullable( arr.find( predicate ) );
+}
+
+export function findIndexInArray<T>( arr: T[], predicate: TPredicate<T> ): TOptional<number> {
+	const idx = arr.findIndex( predicate );
+	return idx === -1 ? Optional.empty() : Optional.of( idx );
+}
+
+export function zip<T, R>( ts: T[], rs: R[] ): [ T, R ][] {
+	if ( ts.length !== rs.length )
+		throw new Error( `Arrays must have the same length. Got ${ts.length} and ${rs.length}` );
+	return ts.map( ( t, i ) => [ t, rs[ i ]! ] as [ T, R ] );
+}
+
+export function unzip<T, R>( arr: [ T, R ][] ): [ T[], R[] ] {
+	return arr.reduce( ( [ ts, rs ], [ t, r ] ) => {
+		return [ [ ...ts, t ], [ ...rs, r ] ];
+	}, [ [], [] ] as [ T[], R[] ] );
+}