Fix sort

.changeset/fruity-cobras-find.md

@@ -0,0 +1,5 @@
+---
+"sortman": major
+---
+
+Fix sort args type

.changeset/icy-brooms-call.md

@@ -0,0 +1,5 @@
+---
+"sortman": major
+---
+
+Fix readme's code template

.changeset/lucky-results-take.md

@@ -0,0 +1,5 @@
+---
+"sortman": major
+---
+
+Fix benchmark algorithm and test code

README.md

@@ -37,8 +37,7 @@ const data = [
 	}
 ];
 
-const sorted = SortMan.sort({
-	arr: data,
+const sorted = SortMan.sort(data, {
 	func: (e) => e.i
 });
 
@@ -67,11 +66,8 @@ import { SortMan } from "sortman";
 
 const data = [200, 300, 100];
 
-const sorted = SortMan.sort({
-	arr: data,
-	options: {
-		desc: true
-	}
+const sorted = SortMan.sort(data, {
+	desc: true
 });
 
 console.log(sorted);

benchmarks/sort.bench.ts

@@ -13,11 +13,12 @@ for (const { name, algorithm } of sorts) {
 					algorithm.sort(numArrData);
 				});
 				bench("Number array in option", () => {
-					algorithm.sort({ arr: numArrData });
+					algorithm.sort(objectArrData, {
+						func: (e) => e.num
+					});
 				});
 				bench("Object array", () => {
-					algorithm.sort({
-						arr: objectArrData,
+					algorithm.sort(objectArrData, {
 						func: (e) => e.num
 					});
 				});

src/Sort/SortBase.ts

@@ -1,28 +1,21 @@
 import { z } from "zod";
 import { inversion } from "../utils/array";
 
-export type SortOptions = {
-	desc?: boolean;
-};
-
-export type SortNumArr = {
-	arr: number[];
-	options?: SortOptions;
-};
-
-export type SortNotNumArr<T> = {
-	arr: T[];
-	func: (e: T) => number;
-	options?: SortOptions;
-};
-
-export type SortElement<T> = T extends number ? T[] | SortNumArr : SortNotNumArr<T>;
-
 export type SortCoreElement<T> = Array<{
 	num: number;
 	content: T;
 }>;
 
+export type SortOptionsFunc<T> = {
+	func: (e: T) => number;
+};
+
+export type SortOptions<T> = (T extends number
+	? Partial<SortOptionsFunc<T>>
+	: Required<SortOptionsFunc<T>>) & {
+	desc?: boolean;
+};
+
 export abstract class SortBase {
 	private isNumArray(arr: unknown): arr is number[] {
 		try {
@@ -33,30 +26,24 @@ export abstract class SortBase {
 		}
 	}
 
-	private getOptions<T>(content: SortElement<T>): SortOptions {
-		if (content instanceof Array) {
-			return {};
-		} else {
-			return content.options ?? {};
-		}
-	}
-
-	public sort<T>(content: SortElement<T>): T[] {
-		const options = this.getOptions(content);
+	public sort<T extends number>(arr: T[]): T[];
+	public sort<T>(arr: T[], options: SortOptions<T>): T[];
+	public sort<T>(arr: T[], options?: SortOptions<T>): T[] {
 		const elements = (() => {
-			if (content instanceof Array) {
-				return content.map((value) => {
-					return { num: value, content: value as T };
-				});
-			}
-			if (this.isNumArray(content.arr)) {
-				return content.arr.map((value) => {
-					return { num: value, content: value as T };
+			if (this.isNumArray(arr)) {
+				return arr.map((value) => {
+					return {
+						num: (options && options.func ? options.func(value) : value) as number,
+						content: value
+					};
 				});
 			} else {
-				const { arr, func } = content as SortNotNumArr<T>;
+				const { func } = options as SortOptionsFunc<T>;
 				return arr.map((value) => {
-					return { num: func(value), content: value };
+					return {
+						num: func(value),
+						content: value
+					};
 				});
 			}
 		})() satisfies SortCoreElement<T>;
@@ -67,11 +54,12 @@ export abstract class SortBase {
 
 		const result = this.core(elements).map(({ content }) => content);
 
-		if (options.desc) {
+		if (options && options.desc) {
 			return inversion(result);
 		}
 
 		return result;
 	}
+
 	public abstract core<T>(content: SortCoreElement<T>): SortCoreElement<T>;
 }

src/index.ts

@@ -7,7 +7,7 @@ import { MergeSort } from "./Sort/MergeSort";
 import { HeapSort } from "./Sort/HeapSort";
 import { ShellSort } from "./Sort/ShellSort";
 
-import type { SortElement } from "./Sort/SortBase";
+import type { SortOptions } from "./Sort/SortBase";
 
 export class SortMan {
 	public static readonly bogo = new BogoSort();
@@ -19,11 +19,13 @@ export class SortMan {
 	public static readonly insertion = new InsertionSort();
 	public static readonly selection = new SelectionSort();
 
-	public static sort<T>(content: SortElement<T>): T[] {
+	public static sort<T extends number>(arr: T[]): T[];
+	public static sort<T>(arr: T[], options: SortOptions<T>): T[];
+	public static sort<T>(arr: T[], options?: SortOptions<T>): T[] {
 		try {
-			return this.merge.sort(content);
+			return this.merge.sort(arr, options as SortOptions<T>);
 		} catch {
-			return this.insertion.sort(content);
+			return this.insertion.sort(arr, options as SortOptions<T>);
 		}
 	}
 }

tests/sort.test.ts

@@ -11,26 +11,22 @@ for (const { name, algorithm, options } of sorts) {
 					expect(sortCheck(result)).toBe(true);
 				});
 				test("Number array with options", () => {
-					const result = algorithm.sort({
-						arr: numArrData
+					const result = algorithm.sort(numArrData, {
+						func: (e) => e
 					});
 					expect(sortCheck(result)).toBe(true);
 				});
 				test("Object array", () => {
-					const result = algorithm.sort({
-						arr: objectArrData,
+					const result = algorithm.sort(objectArrData, {
 						func: (e) => e.num
 					});
 					expect(sortCheck(result.map(({ num }) => num))).toBe(true);
 				});
 			});
 			describe("Option test", () => {
 				test("Desc", () => {
-					const result = algorithm.sort({
-						arr: numArrData,
-						options: {
-							desc: true
-						}
+					const result = algorithm.sort(numArrData, {
+						desc: true
 					});
 					expect(sortCheck(result, true)).toBe(true);
 				});