test: convert type tests to vitest syntax

src/types.ts

@@ -1,10 +1,3 @@
-type Assert<T extends true> = T;
-type Equal<X, Y> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y
-  ? 1
-  : 2
-  ? true
-  : false;
-
 type Splitter = "-" | "_" | "/" | ".";
 type FirstOfString<S extends string> = S extends `${infer F}${string}`
   ? F
@@ -125,65 +118,3 @@ export type JoinByCase<T, Joiner extends string> = string extends T
   : T extends readonly string[]
   ? JoinLowercaseWords<T, Joiner>
   : never;
-
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-type __tests = [
-  // SplitByCase
-  Assert<Equal<SplitByCase<string>, string[]>>,
-  // default splitters
-  Assert<Equal<SplitByCase<"">, []>>,
-  Assert<Equal<SplitByCase<"foo">, ["foo"]>>,
-  Assert<Equal<SplitByCase<"foo_bar-baz/qux">, ["foo", "bar", "baz", "qux"]>>,
-  Assert<Equal<SplitByCase<"foo--bar-Baz">, ["foo", "", "bar", "Baz"]>>,
-  Assert<Equal<SplitByCase<"foo123-bar">, ["foo123", "bar"]>>,
-  Assert<Equal<SplitByCase<"fooBar">, ["foo", "Bar"]>>,
-  Assert<Equal<SplitByCase<"fooBARBaz">, ["foo", "BAR", "Baz"]>>,
-  Assert<Equal<SplitByCase<"FOOBar">, ["FOO", "Bar"]>>,
-  Assert<Equal<SplitByCase<"ALink">, ["A", "Link"]>>,
-  // custom splitters
-  Assert<
-    Equal<
-      SplitByCase<"foo\\Bar.fuzz-FIZz", "\\" | "." | "-">,
-      ["foo", "Bar", "fuzz", "FI", "Zz"]
-    >
-  >,
-
-  // PascalCase
-  Assert<Equal<PascalCase<string>, string>>,
-  Assert<Equal<PascalCase<string[]>, string>>,
-  // string
-  Assert<Equal<PascalCase<"">, "">>,
-  Assert<Equal<PascalCase<"foo">, "Foo">>,
-  Assert<Equal<PascalCase<"foo-bAr">, "FooBAr">>,
-  Assert<Equal<PascalCase<"FooBARb">, "FooBARb">>,
-  Assert<Equal<PascalCase<"foo_bar-baz/qux">, "FooBarBazQux">>,
-  Assert<Equal<PascalCase<"foo--bar-Baz">, "FooBarBaz">>,
-  // array
-  Assert<Equal<PascalCase<["foo", "Bar"]>, "FooBar">>,
-  Assert<
-    Equal<PascalCase<["foo", "Bar", "fuzz", "FI", "Zz"]>, "FooBarFuzzFIZz">
-  >,
-
-  // CamelCase
-  Assert<Equal<CamelCase<string>, string>>,
-  Assert<Equal<CamelCase<string[]>, string>>,
-  // string
-  Assert<Equal<CamelCase<"">, "">>,
-  Assert<Equal<CamelCase<"foo">, "foo">>,
-  Assert<Equal<CamelCase<"FooBARb">, "fooBARb">>,
-  Assert<Equal<CamelCase<"foo_bar-baz/qux">, "fooBarBazQux">>,
-  // array
-  Assert<Equal<CamelCase<["Foo", "Bar"]>, "fooBar">>,
-
-  // JoinByCase
-  Assert<Equal<JoinByCase<string, "-">, string>>,
-  Assert<Equal<JoinByCase<string[], "-">, string>>,
-  // string
-  Assert<Equal<JoinByCase<"", "-">, "">>,
-  Assert<Equal<JoinByCase<"foo", "-">, "foo">>,
-  Assert<Equal<JoinByCase<"FooBARb", "-">, "foo-ba-rb">>,
-  Assert<Equal<JoinByCase<"foo_bar-baz/qux", "-">, "foo-bar-baz-qux">>,
-  // array
-  Assert<Equal<JoinByCase<["Foo", "Bar"], "-">, "foo-bar">>
-];
-/* eslint-enable @typescript-eslint/no-unused-vars */

test/types.test.ts

@@ -0,0 +1,94 @@
+import { describe, test, assertType, expectTypeOf } from "vitest";
+import type {
+  SplitByCase,
+  PascalCase,
+  CamelCase,
+  JoinByCase,
+} from "../src/types";
+
+describe("SplitByCase", () => {
+  test("types", () => {
+    expectTypeOf<SplitByCase<string>>().toEqualTypeOf<string[]>();
+  });
+
+  test("default splitters", () => {
+    assertType<SplitByCase<"">>([]);
+    assertType<SplitByCase<"foo">>(["foo"]);
+    assertType<SplitByCase<"foo_bar-baz/qux">>(["foo", "bar", "baz", "qux"]);
+    assertType<SplitByCase<"foo--bar-Baz">>(["foo", "", "bar", "Baz"]);
+    assertType<SplitByCase<"foo123-bar">>(["foo123", "bar"]);
+    assertType<SplitByCase<"fooBar">>(["foo", "Bar"]);
+    assertType<SplitByCase<"fooBARBaz">>(["foo", "BAR", "Baz"]);
+    assertType<SplitByCase<"FOOBar">>(["FOO", "Bar"]);
+    assertType<SplitByCase<"ALink">>(["A", "Link"]);
+  });
+
+  test("custom splitters", () => {
+    assertType<SplitByCase<"foo\\Bar.fuzz-FIZz", "\\" | "." | "-">>([
+      "foo",
+      "Bar",
+      "fuzz",
+      "FI",
+      "Zz",
+    ]);
+  });
+});
+
+describe("PascalCase", () => {
+  test("types", () => {
+    expectTypeOf<PascalCase<string>>().toEqualTypeOf<string>();
+    expectTypeOf<PascalCase<string[]>>().toEqualTypeOf<string>();
+  });
+
+  test("string", () => {
+    assertType<PascalCase<"">>("");
+    assertType<PascalCase<"foo">>("Foo");
+    assertType<PascalCase<"foo-bAr">>("FooBAr");
+    assertType<PascalCase<"FooBARb">>("FooBARb");
+    assertType<PascalCase<"foo_bar-baz/qux">>("FooBarBazQux");
+    assertType<PascalCase<"foo--bar-Baz">>("FooBarBaz");
+  });
+
+  test("array", () => {
+    assertType<PascalCase<["foo", "Bar"]>>("FooBar");
+    assertType<PascalCase<["foo", "Bar", "fuzz", "FI", "Zz"]>>(
+      "FooBarFuzzFIZz"
+    );
+  });
+});
+
+describe("CamelCase", () => {
+  test("types", () => {
+    expectTypeOf<CamelCase<string>>().toEqualTypeOf<string>();
+    expectTypeOf<CamelCase<string[]>>().toEqualTypeOf<string>();
+  });
+
+  test("string", () => {
+    assertType<CamelCase<"">>("");
+    assertType<CamelCase<"foo">>("foo");
+    assertType<CamelCase<"FooBARb">>("fooBARb");
+    assertType<CamelCase<"foo_bar-baz/qux">>("fooBarBazQux");
+  });
+
+  test("array", () => {
+    assertType<CamelCase<["Foo", "Bar"]>>("fooBar");
+  });
+});
+
+describe("JoinByCase", () => {
+  test("types", () => {
+    expectTypeOf<JoinByCase<string, "-">>().toEqualTypeOf<string>();
+    expectTypeOf<JoinByCase<string[], "-">>().toEqualTypeOf<string>();
+  });
+
+  test("string", () => {
+    assertType<JoinByCase<"", "-">>("");
+    assertType<JoinByCase<"foo", "-">>("foo");
+    assertType<JoinByCase<"FooBARb", "-">>("foo-ba-rb");
+    assertType<JoinByCase<"foo_bar-baz/qux", "-">>("foo-bar-baz-qux");
+  });
+
+  test("array", () => {
+    assertType<JoinByCase<["Foo", "Bar"], "-">>("foo-bar");
+  });
+});