feat: screw that let's make it simple again

src/assertions/and/index.test.ts

@@ -2,6 +2,7 @@ import { maxValue } from "@assertions/maxValue";
 import { minValue } from "@assertions/minValue";
 import { number } from "@assertions/number";
 import { fc, test } from "@fast-check/vitest";
+import { assert } from "@utils";
 import { expect } from "vitest";
 import { and } from "./index";
 
@@ -10,12 +11,12 @@ const assertion = and([number, minValue(0), maxValue(2)]);
 test.prop([fc.integer({ min: 0, max: 2 })])(
 	"should not throw if value passes all assertions",
 	(value) => {
-		expect(() => assertion(value)).not.toThrow();
+		expect(() => assert(assertion, value)).not.toThrow();
 	},
 );
 
 test.prop([
 	fc.oneof(fc.integer({ max: -1 }), fc.integer({ min: 3 }), fc.string()),
 ])("should throw if value does not pass all assertions", (value) => {
-	expect(() => assertion(value)).toThrow();
+	expect(() => assert(assertion, value)).toThrow();
 });

src/assertions/and/index.ts

@@ -1,4 +1,5 @@
-import type { AndSchema, Validate } from "@assertions/and/types";
+import type { Assertion } from "@the-minimal/types";
+import type { Intersection } from "./types";
 
 /**
  * Checks if all the assertions pass.
@@ -18,9 +19,14 @@ import type { AndSchema, Validate } from "@assertions/and/types";
  * userEmail("[email protected]"); // passes
  * ```
  */
-export const and = <const $Schema extends AndSchema>(assertions: $Schema) =>
-	((v: unknown) => {
+export const and =
+	<const $Values extends unknown[]>(
+		assertions: {
+			[$Key in keyof $Values]: Assertion<$Values[$Key]>;
+		},
+	): Assertion<Intersection<$Values>> =>
+	(v: unknown) => {
 		for (let i = 0; i < assertions.length; ++i) {
-			((assertions as any)[i] as any)(v);
+			(assertions[i] as any)(v);
 		}
-	}) as unknown as Validate.And<$Schema>;
+	};

src/assertions/and/types.ts

@@ -0,0 +1,9 @@
+// TODO: move into @the-minimal/types
+export type Intersection<$Values extends unknown[]> = $Values extends [
+	infer $Head,
+	...infer $Tail,
+]
+	? $Tail extends [infer _1, ...infer _2]
+		? $Head & Intersection<$Tail>
+		: $Head
+	: never;

src/assertions/and2/index.ts

@@ -1,5 +1,8 @@
-import type { Validate } from "@assertions/and/types";
-import type { AnyBrand } from "@the-minimal/types";
+import type {
+	Assertion,
+	InferAssertion,
+	UnknownAssertion,
+} from "@the-minimal/types";
 
 /**
  * Checks that both assertions pass.
@@ -16,11 +19,12 @@ import type { AnyBrand } from "@the-minimal/types";
  * userEmail("[email protected]"); // passes
  * ```
  */
-export const and2 = <$Brand1 extends AnyBrand, $Brand2 extends AnyBrand>(
-	brand1: $Brand1,
-	brand2: $Brand2,
-) =>
-	((v: unknown) => {
-		(brand1 as any)(v);
-		(brand2 as any)(v);
-	}) as unknown as Validate.And<[$Brand1, $Brand2]>;
+export const and2 =
+	<$Assertion1 extends UnknownAssertion, $Assertion2 extends UnknownAssertion>(
+		assertion1: $Assertion1,
+		assertion2: $Assertion2,
+	): Assertion<InferAssertion<$Assertion1> & InferAssertion<$Assertion2>> =>
+	(v: unknown) => {
+		assertion1(v);
+		assertion2(v);
+	};

src/assertions/and3/index.ts

@@ -1,5 +1,8 @@
-import type { Validate } from "@assertions/and/types";
-import type { AnyBrand } from "@the-minimal/types";
+import type {
+	Assertion,
+	InferAssertion,
+	UnknownAssertion,
+} from "@the-minimal/types";
 
 /**
  * Checks that all three assertions pass.
@@ -18,17 +21,22 @@ import type { AnyBrand } from "@the-minimal/types";
  * userEmail("[email protected]"); // passes
  * ```
  */
-export const and3 = <
-	$Brand1 extends AnyBrand,
-	$Brand2 extends AnyBrand,
-	$Brand3 extends AnyBrand,
->(
-	brand1: $Brand1,
-	brand2: $Brand2,
-	brand3: $Brand3,
-) =>
-	((v: unknown) => {
-		(brand1 as any)(v);
-		(brand2 as any)(v);
-		(brand3 as any)(v);
-	}) as unknown as Validate.And<[$Brand1, $Brand2, $Brand3]>;
+export const and3 =
+	<
+		$Assertion1 extends UnknownAssertion,
+		$Assertion2 extends UnknownAssertion,
+		$Assertion3 extends UnknownAssertion,
+	>(
+		assertion1: $Assertion1,
+		assertion2: $Assertion2,
+		assertion3: $Assertion3,
+	): Assertion<
+		InferAssertion<$Assertion1> &
+			InferAssertion<$Assertion2> &
+			InferAssertion<$Assertion3>
+	> =>
+	(v: unknown) => {
+		assertion1(v);
+		assertion2(v);
+		assertion3(v);
+	};

src/assertions/array/index.ts

@@ -1,11 +1,10 @@
 import { isArray } from "@assertions/isArray";
-import type { AnyBrand } from "@the-minimal/types";
-import type { Validate } from "./types";
+import type { UnknownAssertion } from "@the-minimal/types";
 
 /**
  * Checks that assertion passes for each element of the array.
  *
- * @param brand - Assertion to be applied to each element of the array.
+ * @param assertion - Assertion to be applied to each element of the array.
  *
  * @example
  * ```ts
@@ -15,11 +14,12 @@ import type { Validate } from "./types";
  * numbers([1, 2, 3]); // passes
  * ```
  */
-export const array = <$Brand extends AnyBrand>(brand: $Brand) =>
-	((v: any) => {
-		(isArray as any)(v);
+export const array =
+	<$Assertion extends UnknownAssertion>(assertion: $Assertion) =>
+	(v: unknown) => {
+		isArray(v);
 
 		for (let i = 0; i < v.length; ++i) {
-			(brand as any)((v as any)[i]);
+			assertion((v as any)[i]);
 		}
-	}) as unknown as Validate.Array<$Brand>;
+	};

src/assertions/boolean/index.ts

@@ -1,5 +1,4 @@
 import { type } from "@assertions/type";
-import type { Validate } from "./types";
 
 /**
  * Checks that the value is a boolean.
@@ -10,4 +9,4 @@ import type { Validate } from "./types";
  * boolean(true); // passes
  * ```
  */
-export const boolean = type("boolean") as Validate.Type.Boolean;
+export const boolean = type<boolean>("boolean");

src/assertions/email/index.ts

@@ -1,5 +1,4 @@
 import { regex } from "@assertions/regex";
-import type { Validate } from "./types";
 
 /**
  * Checks if value matches email RegExp.
@@ -10,4 +9,4 @@ import type { Validate } from "./types";
  * email("[email protected]"); // passes
  * ```
  */
-export const email = regex(/^\w+@.+\..+$/) as Validate.Regex.Email;
+export const email = regex(/^\w+@.+\..+$/);

src/assertions/endsWith/index.ts

@@ -1,10 +1,10 @@
 import { error } from "@error";
-import type { Validate } from "./types";
+import type { Assertion } from "@the-minimal/types";
 
 /**
  * Checks if value ends with `searchString`.
  *
- * @param searchString - The characters to be searched for at the end of value.
+ * @param input - The characters to be searched for at the end of value.
  *
  * @throws `endsWith` if value does not end with `searchString`.
  *
@@ -16,9 +16,7 @@ import type { Validate } from "./types";
  * question("really?"); // passes
  * ```
  */
-export const endsWith = <$SearchString extends string>(
-	searchString: $SearchString,
-) =>
-	((v: any) =>
-		v.endsWith(searchString) ||
-		error(endsWith)) as unknown as Validate.String.EndsWith<$SearchString>;
+export const endsWith =
+	<$Input extends string>(input: $Input): Assertion<unknown> =>
+	(v: unknown) =>
+		(v as any).endsWith(input) || error(endsWith);

src/assertions/expect/index.ts

@@ -1,11 +1,10 @@
-import type { Message } from "@assertions/expect/types";
 import { error } from "@error";
-import type { AnyBrand } from "@the-minimal/types";
+import type { UnknownAssertion } from "@the-minimal/types";
 
 /**
  * Wraps assertion and throws an error with message if assertion fails.
  *
- * @param brand - Assertion to be checked.
+ * @param assertion - Assertion to be checked.
  * @param message - Message to be used in error.
  *
  * @example
@@ -16,14 +15,14 @@ import type { AnyBrand } from "@the-minimal/types";
  * );
  * ```
  */
-export const expect = <$Brand extends AnyBrand>(
-	brand: $Brand,
-	message: Message,
+export const expect = <$Assertion extends UnknownAssertion>(
+	assertion: $Assertion,
+	message: (error: any, value: unknown) => string,
 ) =>
 	((v: unknown) => {
 		try {
-			(brand as any)(v);
-		} catch (e: any) {
-			error(brand, message(e, v));
+			assertion(v);
+		} catch (e) {
+			error(assertion, message(e, v));
 		}
-	}) as unknown as $Brand;
+	}) as $Assertion;

src/assertions/includes/index.ts

@@ -1,5 +1,5 @@
-import type { Validate } from "@assertions/includes/types";
 import { error } from "@error";
+import type { Assertion } from "@the-minimal/types";
 
 /**
  * Checks if value includes with another value.
@@ -14,7 +14,7 @@ import { error } from "@error";
  * hello("--hello--"); // passes
  * ```
  */
-export const includes = <const $Input>(input: $Input) =>
-	((v: any) =>
-		v.includes(input) ||
-		error(includes)) as unknown as Validate.List.Includes<$Input>;
+export const includes =
+	(input: unknown): Assertion<unknown> =>
+	(v: unknown) =>
+		(v as any).includes(input) || error(includes);

src/assertions/integer/index.ts

@@ -1,5 +1,5 @@
-import type { Validate } from "@assertions/integer/types";
 import { error } from "@error";
+import type { Assertion } from "@the-minimal/types";
 
 /**
  * Checks if value is integer.
@@ -10,5 +10,5 @@ import { error } from "@error";
  * integer(1) // passes
  * ```
  */
-export const integer = ((v: unknown) =>
-	Number.isInteger(v) || error(integer)) as unknown as Validate.Number.Integer;
+export const integer: Assertion<unknown> = (v: unknown) =>
+	Number.isInteger(v) || error(integer);