feat: greatly rework how assertions and brands work

package.json

@@ -48,7 +48,7 @@
     "build:stats": "bun run scripts/stats.ts",
     "build:imports": "bun run scripts/imports.ts",
     "build:website": "typedoc --basePath ./ --entryPoints src/index.ts --out website",
-    "test": "vitest run --typecheck",
+    "test": "vitest run",
     "test:coverage": "vitest run --coverage",
     "check": "bunx @biomejs/biome check --apply ./"
   },
@@ -70,6 +70,6 @@
     "access": "public"
   },
   "dependencies": {
-    "@the-minimal/types": "0.2.2"
+    "@the-minimal/types": "0.3.6"
   }
 }

src/assertions/and/index.ts

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

src/assertions/and/types.d.ts

@@ -1,16 +1,47 @@
-import type { Assertion } from "@the-minimal/types";
+import { and } from "@assertions/and/index";
+import type { AnyBrand, Brand, None } from "@the-minimal/types";
 
-export type AndSchema = Array<unknown>;
+export namespace Validate {
+	export type And<$Types extends AndSchema> = Brand<
+		"and",
+		$Schema,
+		{
+			input: InferAndInputs<FilterAndInputs<$Types>>;
+			output: InferAndOutputs<$Types>;
+		}
+	>;
+}
 
-export type InferAndSchema<$Schema extends AndSchema> = {
-	[$Key in keyof $Schema]: Assertion<$Schema[$Key]>;
-};
+export type AndSchema = AnyBrand[];
 
-export type InferAndOutput<$Schema extends AndSchema> = $Schema extends [
+export type InferAndInputs<$Types extends unknown[]> = $Types extends [
 	infer $Head,
 	...infer $Tail,
 ]
-	? $Tail extends [infer $1, ...infer $2]
-		? $Head & InferAndOutput<$Tail>
+	? $Tail extends [infer _1, ...infer _2]
+		? $Head & InferAndOutputs<$Tail>
 		: $Head
 	: never;
+
+type FilterAndInputs<$Schema extends AndSchema> = $Schema extends readonly [
+	infer $Head,
+	...infer $Tail,
+]
+	? $Tail extends readonly [infer _1, ...infer _2]
+		? $Head extends Brand<any, any, { input: infer $Input; output: any }>
+			? [$Input, ...FilterAndInputs<$Tail>]
+			: []
+		: $Head extends Brand<any, any, { input: infer $Input; output: any }>
+			? [$Input]
+			: []
+	: [];
+
+export type InferAndOutputs<$Schema extends AndSchema> =
+	$Schema extends readonly [infer $Head, ...infer $Tail]
+		? $Tail extends readonly [infer _1, ...infer _2]
+			? ($Head extends Brand<any, any, { input: infer $Input; output: any }>
+					? $Input
+					: $Head) &
+					InferAndOutputs<$Tail>
+			: $Head
+		: never;

src/assertions/and2/index.ts

@@ -1,4 +1,5 @@
-import type { Assertion } from "@the-minimal/types";
+import type { Validate } from "@assertions/and/types";
+import type { AnyBrand } from "@the-minimal/types";
 
 /**
  * Checks that both assertions pass.
@@ -15,12 +16,11 @@ import type { Assertion } from "@the-minimal/types";
  * userEmail("[email protected]"); // passes
  * ```
  */
-export const and2 =
-	<$Input1, $Input2>(
-		assertion1: Assertion<$Input1>,
-		assertion2: Assertion<$Input2>,
-	): Assertion<$Input1 & $Input2> =>
-	(v) => {
-		assertion1(v);
-		assertion2(v);
-	};
+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]>;

src/assertions/and3/index.ts

@@ -1,4 +1,5 @@
-import type { Assertion } from "@the-minimal/types";
+import type { Validate } from "@assertions/and/types";
+import type { AnyBrand } from "@the-minimal/types";
 
 /**
  * Checks that all three assertions pass.
@@ -17,14 +18,17 @@ import type { Assertion } from "@the-minimal/types";
  * userEmail("[email protected]"); // passes
  * ```
  */
-export const and3 =
-	<$Input1, $Input2, $Input3>(
-		assertion1: Assertion<$Input1>,
-		assertion2: Assertion<$Input2>,
-		assertion3: Assertion<$Input3>,
-	): Assertion<$Input1 & $Input2 & $Input3> =>
-	(v) => {
-		assertion1(v);
-		assertion2(v);
-		assertion3(v);
-	};
+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]>;

src/assertions/array/index.ts

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

src/assertions/array/types.d.ts

@@ -0,0 +1,13 @@
+import type { AnyBrand, Brand, None } from "@the-minimal/types";
+import type { InferInput } from "@types";
+
+export namespace Validate {
+	export type Array<$Brand extends AnyBrand> = Brand<
+		"array",
+		$Brand,
+		{
+			input: InferInput<$Brand>[];
+			output: None;
+		}
+	>;
+}

src/assertions/boolean/index.test.ts

@@ -1,17 +1,18 @@
 import { boolean } from "@assertions/boolean";
 import { fc, test } from "@fast-check/vitest";
+import { assert } from "@utils";
 import { expect } from "vitest";
 
 test.prop([fc.boolean()])(
 	"should not throw if value is of type boolean",
 	(value) => {
-		expect(() => boolean(value)).not.toThrow();
+		expect(() => assert(boolean, value)).not.toThrow();
 	},
 );
 
 test.prop([fc.string()])(
 	"should throw if value is not of type boolean",
 	(value) => {
-		expect(() => boolean(value)).toThrow();
+		expect(() => assert(boolean, value)).toThrow();
 	},
 );

src/assertions/boolean/index.ts

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

src/assertions/boolean/types.d.ts

@@ -0,0 +1,14 @@
+import type { Brand } from "@the-minimal/types";
+
+export namespace Validate {
+	export namespace Type {
+		export type Boolean = Brand<
+			"type",
+			"boolean",
+			{
+				input: boolean;
+				output: boolean;
+			}
+		>;
+	}
+}

src/assertions/email/index.ts

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

src/assertions/email/types.d.ts

@@ -1,3 +1,7 @@
-import type { Regex } from "@assertions/regex/types";
+import type { Brand } from "@the-minimal/types";
 
-export type Email = Regex<"email">;
+export namespace Validate {
+	export namespace Regex {
+		export type Email = Brand<"regex", "email">;
+	}
+}

src/assertions/endsWith/index.ts

@@ -1,6 +1,5 @@
-import type { EndsWith } from "@assertions/endsWith/types";
 import { error } from "@error";
-import type { Assertion } from "@the-minimal/types";
+import type { Validate } from "./types";
 
 /**
  * Checks if value ends with `searchString`.
@@ -17,9 +16,9 @@ import type { Assertion } from "@the-minimal/types";
  * question("really?"); // passes
  * ```
  */
-export const endsWith =
-	<$SearchString extends string>(
-		searchString: $SearchString,
-	): Assertion<EndsWith<$SearchString>> =>
-	(v: any) =>
-		v.endsWith(searchString) || error(endsWith);
+export const endsWith = <$SearchString extends string>(
+	searchString: $SearchString,
+) =>
+	((v: any) =>
+		v.endsWith(searchString) ||
+		error(endsWith)) as unknown as Validate.String.EndsWith<$SearchString>;

src/assertions/endsWith/types.d.ts

@@ -1,3 +1,10 @@
 import type { Brand } from "@the-minimal/types";
 
-export type EndsWith<$Input> = Brand<"EndsWith", $Input>;
+export namespace Validate {
+	export namespace String {
+		export type EndsWith<$Type extends string> = Brand<
+			"string-endswith",
+			$Type
+		>;
+	}
+}

src/assertions/includes/index.ts

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

src/assertions/includes/types.d.ts

@@ -1,3 +1,7 @@
 import type { Brand } from "@the-minimal/types";
 
-export type Includes<$Input> = Brand<"Includes", $Input>;
+export namespace Validate {
+	export namespace List {
+		export type Includes<$Input> = Brand<"list-includes", $Input>;
+	}
+}

src/assertions/integer/index.ts

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

src/assertions/integer/types.d.ts

@@ -1,3 +1,7 @@
 import type { Brand } from "@the-minimal/types";
 
-export type Integer = Brand<"Integer">;
+export namespace Validate {
+	export namespace Number {
+		export type Integer = Brand<"number-integer">;
+	}
+}

src/assertions/lazy/index.ts

@@ -1,4 +1,4 @@
-import type { UnknownAssertion } from "@the-minimal/types";
+import type { AnyBrand } from "@the-minimal/types";
 
 /**
  * Wraps assertion in a function that will be evaluated only when the assertion is called.
@@ -20,9 +20,9 @@ import type { UnknownAssertion } from "@the-minimal/types";
  * }); // passes
  * ```
  */
-export const lazy = <$Validation extends UnknownAssertion>(
+export const lazy = <$Validation extends AnyBrand>(
 	assertion: (input: unknown) => $Validation,
 ) =>
 	((input: unknown) => {
 		(assertion(input) as any)(input);
-	}) as $Validation;
+	}) as unknown as $Validation;