feat: add unit test

Author: mathcovax

scripts/common/clone.test.ts

@@ -1,5 +1,5 @@
 import { type ObjectKey } from "@scripts/object/types/objectKey";
-import { getTypedEntries } from "../object/getTypedEntries";
+import { getEntries } from "../object/getEntries";
 import { type SimplifyTypeForce } from "@scripts/common/types/simplifyTypeForce";
 
 export function clone<
@@ -12,7 +12,7 @@ export function clone<
 	} else if (unknownValue instanceof Array) {
 		return <never>unknownValue.map(clone);
 	} else {
-		return <never>getTypedEntries(unknownValue)
+		return <never>getEntries(unknownValue)
 			.reduce<Record<ObjectKey, unknown>>(
 				(pv, [key, value]) => {
 					pv[key] = clone(value);

scripts/common/clone.ts

@@ -3,8 +3,8 @@ export function createExternalPromise<
 >() {
 	type PossibleValue = Awaited<GenericPromiseValue> | GenericPromiseValue | Promise<GenericPromiseValue>;
 
-	let resolve = (_value: PossibleValue) => {};
-	let reject = (_value: unknown) => {};
+	let resolve = undefined as unknown as (_value: PossibleValue) => void;
+	let reject = undefined as unknown as (_value: unknown) => void;
 	const promise = new Promise<Awaited<GenericPromiseValue>>((res, rej) => {
 		resolve = res as never;
 		reject = rej;

scripts/common/escapeRegExp.test.ts

@@ -1,8 +1,8 @@
-import { getTypedEntries } from "../object/getTypedEntries";
+import { getEntries } from "../object/getEntries";
 
 export function simpleClone<
-	T extends unknown = unknown,
->(unknownValue: T): T {
+	GenericObject extends unknown = unknown,
+>(unknownValue: GenericObject): GenericObject {
 	if (!unknownValue) {
 		return unknownValue;
 	} else if (typeof unknownValue !== "object") {
@@ -11,15 +11,15 @@ export function simpleClone<
 		unknownValue.constructor?.name === "Object"
 		|| unknownValue.constructor === undefined
 	) {
-		return getTypedEntries(unknownValue).reduce(
+		return getEntries(unknownValue).reduce(
 			(pv, [key, value]) => {
 				pv[key] = simpleClone(value);
 				return pv;
 			},
-			{} as T,
+			{} as GenericObject,
 		);
 	} else if (unknownValue instanceof Array && unknownValue.constructor.name === "Array") {
-		return unknownValue.map(simpleClone) as T;
+		return unknownValue.map(simpleClone) as GenericObject;
 	} else {
 		return unknownValue;
 	}

scripts/common/externalPromise.ts

@@ -13,7 +13,7 @@ export class InvalidBytesInStringError extends Error {
 	}
 }
 
-const parseRegExp = /^((-|\+)?(\d+(?:\.\d+)?)) *(kb|mb|gb|tb|pb)$/i;
+const parseRegExp = /(?<rawValue>[0-9.]+)(?<unit>b|kb|mb|gb|tb|pd)/;
 
 const unitMapper = {
 	b: 1,
@@ -33,17 +33,12 @@ export function stringToBytes(bytesInString: BytesInString | number) {
 
 	const regExpResults = parseRegExp.exec(bytesInString);
 
-	const floatValue = regExpResults
-		? parseFloat(regExpResults[1]!)
-		: parseInt(bytesInString, 10);
+	const { rawValue, unit } = regExpResults?.groups ?? {};
+	const value = parseFloat(rawValue ?? "");
 
-	const unit = regExpResults
-		? regExpResults[4]!.toLowerCase()
-		: "b";
-
-	if (!hasKey(unitMapper, unit) || isNaN(floatValue)) {
+	if (isNaN(value) || !unit || !hasKey(unitMapper, unit)) {
 		throw new InvalidBytesInStringError(bytesInString);
 	}
 
-	return Math.floor(unitMapper[unit] * floatValue);
+	return Math.floor(unitMapper[unit] * value);
 }