@zelgadis87/utils-core 4.13.0 → 4.13.2

package/package.json

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

package/src/sorting/Sorter.ts

@@ -76,11 +76,11 @@ const compareDates = <T, R extends Date>( fns: ReadonlyArray<TComparisonFunction
 	return chain( fns, compareFunction( transform, naturalOrderComparison, { nullsFirst, direction } ) );
 };
 const compareTimeInstants = <T, R extends TimeInstant>( fns: ReadonlyArray<TComparisonFunction<T>>, transform: TFunction<T, R>, options: TConditionalParameterOptions<TTimeInstantComparisonOptions, typeof defaultTimeInstantComparisonOptions> = {} ) => {
-	const { nullsFirst, direction } = { ...defaultDateComparisonOptions, ...options };
+	const { nullsFirst, direction } = { ...defaultTimeInstantComparisonOptions, ...options };
 	return chain( fns, compareFunction( transform, ( a, b ) => a.isBefore( b ) ? -1 : 1, { nullsFirst, direction } ) );
 };
 const compareTimeDurations = <T, R extends TimeDuration>( fns: ReadonlyArray<TComparisonFunction<T>>, transform: TFunction<T, R>, options: TConditionalParameterOptions<TTimeDurationComparisonOptions, typeof defaultTimeDurationComparisonOptions> = {} ) => {
-	const { nullsFirst, direction } = { ...defaultDateComparisonOptions, ...options };
+	const { nullsFirst, direction } = { ...defaultTimeDurationComparisonOptions, ...options };
 	return chain( fns, compareFunction( transform, ( a, b ) => a.isLessThan( b ) ? -1 : 1, { nullsFirst, direction } ) );
 };
 const compareBooleans = <T, R extends boolean>( fns: ReadonlyArray<TComparisonFunction<T>>, transform: TFunction<T, R>, options: TConditionalParameterOptions<TBooleanComparisonOptions, typeof defaultBooleanComparisonOptions> ) => {
@@ -134,6 +134,8 @@ const next = <T, R>( fns: ReadonlyArray<TComparisonFunction<T>>, transform: TFun
 		usingNumbers: field => using( t => t[ field ] ),
 		usingBooleans: field => using( t => t[ field ] ),
 		usingDates: field => using( t => t[ field ] ),
+		usingTimeInstant: field => using( t => t[ field ] ),
+		usingTimeDuration: field => using( t => t[ field ] ),
 	} as const satisfies TSorterStepForRecords<R, TSorter<T>>;
 	const retForNumbers = {
 		...retAsUsing,
@@ -293,10 +295,12 @@ export type TSorter<T> = {
 }
 
 type TSorterStepForRecords<T, Ret> = {
-	usingStrings: ( field: TKeysOfType<T, string> ) => TSorterStep<string, Ret>;
-	usingNumbers: ( field: TKeysOfType<T, number> ) => TSorterStep<number, Ret>;
-	usingBooleans: ( field: TKeysOfType<T, boolean> ) => TSorterStep<boolean, Ret>;
-	usingDates: ( field: TKeysOfType<T, Date> ) => TSorterStep<Date, Ret>;
+	usingStrings: ( field: TKeysOfType<T, string> ) => TSorterStepUsing<string, Ret>;
+	usingNumbers: ( field: TKeysOfType<T, number> ) => TSorterStepUsing<number, Ret>;
+	usingBooleans: ( field: TKeysOfType<T, boolean> ) => TSorterStepUsing<boolean, Ret>;
+	usingDates: ( field: TKeysOfType<T, Date> ) => TSorterStepUsing<Date, Ret>;
+	usingTimeInstant: ( field: TKeysOfType<T, TimeInstant> ) => TSorterStepUsing<TimeInstant, Ret>;
+	usingTimeDuration: ( field: TKeysOfType<T, TimeDuration> ) => TSorterStepUsing<TimeDuration, Ret>;
 };
 type TSorterStepForNumbers<_T, Ret> = {
 	inAscendingOrder( opts?: { nullsFirst?: boolean } ): Ret;
@@ -328,7 +332,7 @@ type TSorterStepForChainables<T, Ret> = {
 	chain: ( chain: TComparable<T> ) => Ret;
 };
 type TSorterStepForUsing<T, Ret> = {
-	using: <X>( transform: TFunction<T, X> ) => TSorterStep<X, Ret>;
+	using: <X>( transform: TFunction<T, X> ) => TSorterStepUsing<X, Ret>;
 };
 type TSorterStepForPrioritizable<T extends string | number, Ret> = {
 	prioritizing( arr: T[], options?: TConditionalParameterOptions<TPrioritizeOptions, typeof defaultPrioritizeOptions> ): Ret;
@@ -336,7 +340,7 @@ type TSorterStepForPrioritizable<T extends string | number, Ret> = {
 	prioritizingWithEqualWeight( arr: T[], options?: TConditionalParameterOptions<TPrioritizeOptions, typeof defaultPrioritizeOptions> ): Ret;
 	deprioritizingWithEqualWeight( arr: Array<T>, options?: TConditionalParameterOptions<TPrioritizeOptions, typeof defaultPrioritizeOptions> ): Ret;
 };
-type TSorterStep<T, Ret> = {}
+type TSorterStepUsing<T, Ret> = {}
 	& ( T extends Record<string | number | symbol, unknown> ? TSorterStepForRecords<T, Ret> : {} )
 	& ( T extends number ? TSorterStepForNumbers<T, Ret> : {} )
 	& ( T extends string ? TSorterStepForStrings<T, Ret> : {} )
@@ -346,6 +350,8 @@ type TSorterStep<T, Ret> = {}
 	& ( T extends TimeDuration ? TSorterStepForTimeDuration<T, Ret> : {} )
 	& ( T extends string ? TSorterStepForPrioritizable<string, Ret> : {} ) // Allowing all types of strings here is needed because literal types extending strings create compilation problems with method signatures (T[] where T = 'A' | 'B' becomes 'A'[] & 'B'[])
 	& ( T extends number ? TSorterStepForPrioritizable<number, Ret> : {} ) // Allowing all types of numbers here is needed because literal types extending numbers create compilation problems with method signatures (T[] where T = 1 | 2 becomes 1[] & 2[])
+	;
+type TSorterStep<T, Ret> = TSorterStepUsing<T, Ret>
 	& TSorterStepForChainables<T, Ret>
 	& TSorterStepForUsing<T, Ret>
 	;
@@ -359,7 +365,7 @@ type TSorterStepFull<T, Ret> = TSorterStepForRecords<T, Ret>
 	& TSorterStepForChainables<T, Ret>
 	& TSorterStepForUsing<T, Ret>
 	;
-type TSorterStarter<T> = TSorterStep<T, TSorter<T>>;
+type TSorterStarter<T> = TSorterStepUsing<T, TSorter<T>>;
 export type TSorterBuilder<T> = ( builder: TSorterStarter<T> ) => TSorter<T>;
 
 type TStringComparisonOptions = TCompareFunctionOptions & { ignoreCase: boolean };
@@ -383,13 +389,6 @@ const defaultBooleanComparisonOptions = { ...defaultCompareValuesOptions } as co
 type TPrioritizeOptions = {};
 const defaultPrioritizeOptions = {} as const satisfies Partial<TPrioritizeOptions>;
 
-/** 
- * @deprecated[2023-10-19]: Use {@link Sorter.createFor} instead.
- **/
-export function createSorterFor<T>() {
-	return doCreateEmpty<T>();
-}
-
 export const Sorter = {
 	createFor: <T>() => doCreateEmpty<T>(),
 	sort: <T>( arr: TReadableArray<T>, builder: TSorterBuilder<T> ) => builder( doCreateEmpty() ).sort( arr ),