Add type-aware oxlint checks

nikeee · nikeee · commit ea18fcf4426f · 2026-02-20T22:51:52.000+01:00
diff --git a/package-lock.json b/package-lock.json
diff --git a/package.json b/package.json
@@ -21,11 +21,11 @@
   "types": "dist/index.d.mts",
   "scripts": {
     "build": "tsdown",
-    "ci": "tsc --noEmit && oxlint --deny-warnings -f github",
+    "ci": "oxlint --type-aware --type-check --deny-warnings -f github",
     "docs": "typedoc",
     "format": "oxfmt",
-    "lint": "oxlint",
-    "lint:fix": "oxlint --fix",
+    "lint": "oxlint --type-aware",
+    "lint:fix": "oxlint --type-aware --fix",
     "test": "tsc --noEmit && node --test",
     "test:coverage": "node --test --experimental-test-coverage",
     "prepublishOnly": "npm run build"
@@ -35,6 +35,7 @@
     "expect": "^30.2.0",
     "oxfmt": "^0.34.0",
     "oxlint": "^1.49.0",
+    "oxlint-tsgolint": "^0.14.2",
     "tsdown": "^0.20.3",
     "typedoc": "^0.28.16"
   },
diff --git a/src/base62.test.ts b/src/base62.test.ts
@@ -3,19 +3,19 @@ import { expect } from "expect";
 
 import { decode, decodeUnsafe, encode } from "./base62.ts";
 
-describe("base62 roundtrip", () => {
+void describe("base62 roundtrip", () => {
 	function encodeText(value: string): Uint8Array {
 		return new TextEncoder().encode(value);
 	}
 
-	describe("roundtrip", () => {
-		test("empty string", () => {
+	void describe("roundtrip", () => {
+		void test("empty string", () => {
 			const s = encode(new Uint8Array());
 			expect(s).toEqual("");
 			expect(decode(s)).toEqual(new Uint8Array());
 		});
 
-		test("bytes 0..255", () => {
+		void test("bytes 0..255", () => {
 			const data = new Uint8Array(256);
 			for (let i = 0; i < 256; ++i) {
 				data[i] = i;
@@ -29,15 +29,15 @@ describe("base62 roundtrip", () => {
 			expect(decode(s)).toEqual(data);
 		});
 
-		test("encode simple text", () => {
+		void test("encode simple text", () => {
 			const data = encodeText("abc");
 			const s = encode(data);
 
 			expect(s).toEqual("QmIN");
 			expect(decode(s)).toEqual(data);
 		});
 
-		test("encode zeros prefix", () => {
+		void test("encode zeros prefix", () => {
 			const data = new Uint8Array([0, 0, 1, 2, 3]);
 			const s = encode(data);
 
@@ -46,16 +46,16 @@ describe("base62 roundtrip", () => {
 		});
 	});
 
-	describe("parameter validation and exceptions", () => {
-		test("encode rejects non-ArrayBufferView types", () => {
+	void describe("parameter validation and exceptions", () => {
+		void test("encode rejects non-ArrayBufferView types", () => {
 			expect(() => encode("not a buffer" as unknown as Uint8Array)).toThrow(
 				new Error(
 					"`source` has non-supported type. Provide `Uint8Array` or `ArrayBufferView`.",
 				),
 			);
 		});
 
-		test("encode accepts ArrayBufferView (DataView)", () => {
+		void test("encode accepts ArrayBufferView (DataView)", () => {
 			const buf = new ArrayBuffer(3);
 			new Uint8Array(buf).set([1, 2, 3]);
 
@@ -66,13 +66,13 @@ describe("base62 roundtrip", () => {
 			expect(decode(s)).toEqual(new Uint8Array([1, 2, 3]));
 		});
 
-		test("decodeUnsafe rejects non-string input", () => {
+		void test("decodeUnsafe rejects non-string input", () => {
 			expect(() => decodeUnsafe(123 as unknown as string)).toThrow(
 				TypeError("Expected String"),
 			);
 		});
 
-		test("decode/decodeUnsafe handle invalid characters", () => {
+		void test("decode/decodeUnsafe handle invalid characters", () => {
 			expect(decodeUnsafe("!notbase62!")).toBeUndefined();
 			expect(() => decode("!notbase62!")).toThrow(new Error("Failed to decode string"));
 		});
diff --git a/src/crc32.test.ts b/src/crc32.test.ts
@@ -3,56 +3,56 @@ import { expect } from "expect";
 
 import crc32 from "./crc32.ts";
 
-describe("crc32 smoke tests", () => {
+void describe("crc32 smoke tests", () => {
 	function encode(value: string): Uint8Array {
 		return new TextEncoder().encode(value);
 	}
 
-	test("empty string", () => {
+	void test("empty string", () => {
 		const data = new Uint8Array();
 		expect(crc32(data)).toEqual(new Uint8Array([0x00, 0x00, 0x00, 0x00]));
 	});
-	test("The quick brown fox jumps over the lazy dog", () => {
+	void test("The quick brown fox jumps over the lazy dog", () => {
 		const data = encode("The quick brown fox jumps over the lazy dog");
 		expect(crc32(data)).toEqual(new Uint8Array([0x41, 0x4f, 0xa3, 0x39]));
 	});
 
-	test("The quick brown fox jumps over the lazy dog.", () => {
+	void test("The quick brown fox jumps over the lazy dog.", () => {
 		const data = encode("The quick brown fox jumps over the lazy dog.");
 		expect(crc32(data)).toEqual(new Uint8Array([0x51, 0x90, 0x25, 0xe9]));
 	});
 
-	test("abc", () => {
+	void test("abc", () => {
 		const data = encode("abc");
 		expect(crc32(data)).toEqual(new Uint8Array([0x35, 0x24, 0x41, 0xc2]));
 	});
 
-	test("123456789", () => {
+	void test("123456789", () => {
 		const data = encode("123456789");
 		expect(crc32(data)).toEqual(new Uint8Array([0xcb, 0xf4, 0x39, 0x26]));
 	});
 
-	test("a", () => {
+	void test("a", () => {
 		const data = encode("a");
 		expect(crc32(data)).toEqual(new Uint8Array([0xe8, 0xb7, 0xbe, 0x43]));
 	});
 
-	test("message digest", () => {
+	void test("message digest", () => {
 		const data = encode("message digest");
 		expect(crc32(data)).toEqual(new Uint8Array([0x20, 0x15, 0x9d, 0x7f]));
 	});
 
-	test("abcdefghijklmnopqrstuvwxyz", () => {
+	void test("abcdefghijklmnopqrstuvwxyz", () => {
 		const data = encode("abcdefghijklmnopqrstuvwxyz");
 		expect(crc32(data)).toEqual(new Uint8Array([0x4c, 0x27, 0x50, 0xbd]));
 	});
 
-	test("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789", () => {
+	void test("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789", () => {
 		const data = encode("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789");
 		expect(crc32(data)).toEqual(new Uint8Array([0x1f, 0xc2, 0xe6, 0xd2]));
 	});
 
-	test("bytes 0..255", () => {
+	void test("bytes 0..255", () => {
 		const data = new Uint8Array(256);
 		for (let i = 0; i < 256; ++i) {
 			data[i] = i;
diff --git a/src/index.test.ts b/src/index.test.ts
@@ -40,14 +40,14 @@ afterEach(() => {
 
 import { createTokenGenerator } from "./index.ts";
 
-test("Instance creation smoke test", () => {
+void test("Instance creation smoke test", () => {
 	createTokenGenerator({
 		prefixWithoutUnderscore: "test",
 	});
 });
 
-describe("`prefixWithoutUnderscore` validation", () => {
-	test("Instance creation expect prefix", () => {
+void describe("`prefixWithoutUnderscore` validation", () => {
+	void test("Instance creation expect prefix", () => {
 		// @ts-expect-error
 		expect(() => createTokenGenerator({})).toThrow(
 			new Error(
@@ -56,13 +56,13 @@ describe("`prefixWithoutUnderscore` validation", () => {
 		);
 	});
 
-	test("prefixWithoutUnderscore: allowed characters", () => {
+	void test("prefixWithoutUnderscore: allowed characters", () => {
 		expect(() => createTokenGenerator({ prefixWithoutUnderscore: "abc" })).not.toThrow();
 		expect(() => createTokenGenerator({ prefixWithoutUnderscore: "ABC" })).not.toThrow();
 		expect(() => createTokenGenerator({ prefixWithoutUnderscore: "aBc123" })).not.toThrow();
 	});
 
-	test("prefixWithoutUnderscore: disallowed characters", () => {
+	void test("prefixWithoutUnderscore: disallowed characters", () => {
 		expect(() => createTokenGenerator({ prefixWithoutUnderscore: "" })).toThrow();
 		expect(() => createTokenGenerator({ prefixWithoutUnderscore: "_" })).toThrow();
 		expect(() => createTokenGenerator({ prefixWithoutUnderscore: "foo-bar" })).toThrow();
@@ -79,7 +79,7 @@ describe("`prefixWithoutUnderscore` validation", () => {
 	});
 });
 
-test("Instance creation expect proper byte count", () => {
+void test("Instance creation expect proper byte count", () => {
 	expect(() =>
 		createTokenGenerator({
 			prefixWithoutUnderscore: "a",
@@ -112,20 +112,20 @@ test("Instance creation expect proper byte count", () => {
 	});
 });
 
-test("Roundtrip syntax check", () => {
+void test("Roundtrip syntax check", () => {
 	const g = createTokenGenerator({ prefixWithoutUnderscore: "test" });
 	const token = g.generateToken();
 	expect(g.isTokenString(token)).toBe(true);
 });
 
-test("Snapshot + default entropyBytes", () => {
+void test("Snapshot + default entropyBytes", () => {
 	const g = createTokenGenerator({ prefixWithoutUnderscore: "test" });
 	expect(g.generateToken()).toBe("test_1sSTYGlY7FpQhFcPUWjQcyfqQkW1oTDe5D");
 	expect(g.generateToken()).toBe("test_1vEOLndpANaPr8bqfaSnP8yYUL3GZu1Kg9");
 	expect(g.generateToken()).toBe("test_1y0J9KW6DVLP11bHqeCABJHGXvaVO2ngsf");
 });
 
-test("Non-happy paths in isTokenString", () => {
+void test("Non-happy paths in isTokenString", () => {
 	const g = createTokenGenerator({ prefixWithoutUnderscore: "test" });
 
 	// @ts-expect-error
diff --git a/src/parse.test.ts b/src/parse.test.ts
@@ -3,7 +3,7 @@ import { expect } from "expect";
 
 import { parseTokenData, type TokenContents } from "./parse.ts";
 
-test("Parse token contents", () => {
+void test("Parse token contents", () => {
 	let contents: TokenContents | undefined;
 
 	contents = parseTokenData("");
