feat: reduce project size

Author: Mister-Hope

__tests__/base64.spec.ts

@@ -1,35 +1,38 @@
-import { expect, it } from "vitest";
+import { describe, expect, it } from "vitest";
 
 import { decodeBase64, encodeBase64 } from "../src/base64.js";
-import { BASE64_INDEX } from "../src/constant.js";
 
-it("Have correct constant", () => {
-  expect(BASE64_INDEX).toEqual([
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-    -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 54, 55, 56, 57, 58, 59, 60, 61, 62,
-    63, -1, -1, -1, -1, -1, -1, -1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
-    15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, -1, -1, -1, -1, -1, -1,
-    28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46,
-    47, 48, 49, 50, 51, 52, 53, -1, -1, -1, -1, -1,
-  ]);
-});
+describe("encodeBase64", () => {
+  it("should encode byte array to base64 string", () => {
+    expect(
+      encodeBase64(
+        [
+          0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a,
+          0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
+        ],
+        16,
+      ),
+    ).toEqual("..CA.uOD/eaGAOmJB.yMBu");
+  });
 
-it("Encode Base64", () => {
-  expect(
-    encodeBase64(
-      [
-        0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b,
-        0x0c, 0x0d, 0x0e, 0x0f, 0x10,
-      ],
-      16,
-    ),
-  ).toEqual("..CA.uOD/eaGAOmJB.yMBu");
+  it("should throw error for invalid length", () => {
+    expect(() => encodeBase64([1, 2, 3], 0)).toThrow("Illegal length: 0");
+    expect(() => encodeBase64([1, 2, 3], -1)).toThrow("Illegal length: -1");
+    expect(() => encodeBase64([1, 2, 3], 5)).toThrow("Illegal length: 5");
+  });
 });
 
-it("Decode Base64", () => {
-  expect(decodeBase64("..CA.uOD/eaGAOmJB.yMBv.", 16)).toEqual([
-    0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b,
-    0x0c, 0x0d, 0x0e, 0x0f,
-  ]);
+describe("decodeBase64", () => {
+  it("should decode base64 string to byte array", () => {
+    expect(decodeBase64("..CA.uOD/eaGAOmJB.yMBv.", 16)).toEqual([
+      0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b,
+      0x0c, 0x0d, 0x0e, 0x0f,
+    ]);
+  });
+
+  it("should handle invalid characters gracefully", () => {
+    const result = decodeBase64("invalid@char", 5);
+
+    expect(result.length).toBeLessThanOrEqual(5);
+  });
 });

__tests__/compare.spec.ts

@@ -1,4 +1,4 @@
-import { expect, it } from "vitest";
+import { describe, expect, it } from "vitest";
 
 import {
   compare,
@@ -9,29 +9,75 @@ import {
   hashSync,
 } from "../src/index.js";
 
-it("Compare sync", () => {
-  const salt1 = genSaltSync();
-  const hash1 = hashSync("hello", salt1);
-  const salt2 = genSaltSync().replace(/\$2b\$/, "$2y$");
-  const hash2 = hashSync("world", salt2);
+describe("compare", () => {
+  it("should return true for valid password-hash pairs", async () => {
+    const salt1 = await genSalt();
+    const hash1 = await hash("hello", salt1);
+    const salt2 = (await genSalt()).replace(/\$2b\$/, "$2y$");
+    const hash2 = await hash("world", salt2);
 
-  expect(hash1.substring(0, 4)).toBe("$2b$");
-  expect(compareSync("hello", hash1)).toBe(true);
-  expect(compareSync("hello", hash2)).toBe(false);
+    expect(await compare("hello", hash1)).toBe(true);
+    expect(await compare("hello", hash2)).toBe(false);
+    expect(await compare("world", hash1)).toBe(false);
+    expect(await compare("world", hash2)).toBe(true);
+  });
 
-  expect(hash2.substring(0, 4)).toBe("$2y$");
-  expect(compareSync("world", hash1)).toBe(false);
-  expect(compareSync("world", hash2)).toBe(true);
+  it("should reject with error for invalid argument types", async () => {
+    // @ts-expect-error: error type check
+    await expect(compare(123, "hash")).rejects.toThrow(
+      "Illegal arguments: number, string",
+    );
+    // @ts-expect-error: error type check
+    await expect(compare("content", 123)).rejects.toThrow(
+      "Illegal arguments: string, number",
+    );
+    // @ts-expect-error: error type check
+    await expect(compare(123, 456)).rejects.toThrow(
+      "Illegal arguments: number, number",
+    );
+  });
+
+  it("should resolve false for invalid hash length", async () => {
+    await expect(compare("hello", "invalid")).resolves.toBe(false);
+    await expect(compare("hello", "short")).resolves.toBe(false);
+    await expect(compare("hello", "a".repeat(59))).resolves.toBe(false);
+  });
 });
 
-it("Compare async", async () => {
-  const salt1 = await genSalt();
-  const hash1 = await hash("hello", salt1);
-  const salt2 = (await genSalt()).replace(/\$2b\$/, "$2y$");
-  const hash2 = await hash("world", salt2);
+describe("compareSync", () => {
+  it("should return true for valid password-hash pairs", () => {
+    const salt1 = genSaltSync();
+    const hash1 = hashSync("hello", salt1);
+    const salt2 = genSaltSync().replace(/\$2b\$/, "$2y$");
+    const hash2 = hashSync("world", salt2);
+
+    expect(hash1.substring(0, 4)).toBe("$2b$");
+    expect(compareSync("hello", hash1)).toBe(true);
+    expect(compareSync("hello", hash2)).toBe(false);
+
+    expect(hash2.substring(0, 4)).toBe("$2y$");
+    expect(compareSync("world", hash1)).toBe(false);
+    expect(compareSync("world", hash2)).toBe(true);
+  });
+
+  it("should throw error for invalid argument types", () => {
+    // @ts-expect-error: error type check
+    expect(() => compareSync(123, "hash")).toThrow(
+      "Illegal arguments: number, string",
+    );
+    // @ts-expect-error: error type check
+    expect(() => compareSync("content", 123)).toThrow(
+      "Illegal arguments: string, number",
+    );
+    // @ts-expect-error: error type check
+    expect(() => compareSync(123, 456)).toThrow(
+      "Illegal arguments: number, number",
+    );
+  });
 
-  expect(await compare("hello", hash1)).toBe(true);
-  expect(await compare("hello", hash2)).toBe(false);
-  expect(await compare("world", hash1)).toBe(false);
-  expect(await compare("world", hash2)).toBe(true);
+  it("should return false for invalid hash length", () => {
+    expect(compareSync("hello", "invalid")).toBe(false);
+    expect(compareSync("hello", "short")).toBe(false);
+    expect(compareSync("hello", "a".repeat(59))).toBe(false);
+  });
 });

__tests__/hash.spec.ts

@@ -1,19 +1,95 @@
-import { expect, it } from "vitest";
+import { describe, expect, it } from "vitest";
 
 import { hash, hashSync } from "../src/index.js";
 
-it("Hash sync", () => {
-  expect(hashSync("hello", 10)).not.toEqual(hashSync("hello", 10));
-  expect(hashSync("中国我爱你！", 10)).not.toEqual(
-    hashSync("中国我爱你！", 10),
-  );
+describe("hash", () => {
+  it("should generate hash for valid inputs", async () => {
+    const hash1 = await hash("hello", 10);
+    const hash2 = await hash("hello", 10);
+    const hash3 = await hash("中国我爱你！", 10);
+    const hash4 = await hash("中国我爱你！", 10);
+
+    expect(hash1).toBeTypeOf("string");
+    expect(hash2).toBeTypeOf("string");
+    expect(hash3).toBeTypeOf("string");
+    expect(hash4).toBeTypeOf("string");
+    expect(hash1).not.toEqual(hash2);
+    expect(hash3).not.toEqual(hash4);
+  });
+
+  it("should reject for invalid argument types", async () => {
+    // @ts-expect-error: error type check
+    await expect(hash(123, 10)).rejects.toThrow(
+      "Invalid content / salt: not a string",
+    );
+    await expect(hash("hello", "invalid")).rejects.toThrow(
+      "Invalid salt version: in",
+    );
+  });
+
+  it("should reject for invalid salt format", async () => {
+    await expect(hash("hello", "invalid")).rejects.toThrow(
+      "Invalid salt version: in",
+    );
+    await expect(hash("hello", "$1$")).rejects.toThrow(
+      "Invalid salt version: $1",
+    );
+    await expect(hash("hello", "$2x$10$")).rejects.toThrow(
+      "Invalid salt revision: x$",
+    );
+    await expect(hash("hello", "$2a$")).rejects.toThrow(
+      "Illegal salt length: 0 != 16",
+    );
+    await expect(hash("hello", "$2$10$validsalthere")).rejects.toThrow(
+      "Illegal salt length: 9 != 16",
+    );
+    await expect(hash("hello", "$2a$1Z$validsalthere")).rejects.toThrow(
+      "Illegal salt length: 9 != 16",
+    );
+  });
 });
 
-it("Hash async", () => {
-  void hash("hello", 10).then((hash) => {
-    expect(hash).toBeTypeOf("string");
+describe("hashSync", () => {
+  it("should generate hash for valid inputs", () => {
+    const hash1 = hashSync("hello", 10);
+    const hash2 = hashSync("hello", 10);
+    const hash3 = hashSync("中国我爱你！", 10);
+    const hash4 = hashSync("中国我爱你！", 10);
+
+    expect(hash1).toBeTypeOf("string");
+    expect(hash2).toBeTypeOf("string");
+    expect(hash3).toBeTypeOf("string");
+    expect(hash4).toBeTypeOf("string");
+    expect(hash1).not.toEqual(hash2);
+    expect(hash3).not.toEqual(hash4);
   });
-  void hash("中国我爱你！", 10).then((hash) => {
-    expect(hash).toBeTypeOf("string");
+
+  it("should throw error for invalid argument types", () => {
+    // @ts-expect-error: error type check
+    expect(() => hashSync(123, 10)).toThrow(
+      "Invalid content / salt: not a string",
+    );
+    expect(() => hashSync("hello", "invalid")).toThrow(
+      "Invalid salt version: in",
+    );
+  });
+
+  it("should throw error for invalid salt format", () => {
+    expect(() => hashSync("hello", "invalid")).toThrow(
+      "Invalid salt version: in",
+    );
+    expect(() => hashSync("hello", "$1$")).toThrow("Invalid salt version: $1");
+    expect(() => hashSync("hello", "$2x$10$valid_salt_here")).toThrow(
+      "Invalid salt revision: x$",
+    );
+    expect(() => hashSync("hello", "$2a$0")).toThrow(
+      "Illegal salt length: 0 != 16",
+    );
+    expect(() => hashSync("hello", "$2$10$validsalthere")).toThrow(
+      "Illegal salt length: 9 != 16",
+    );
+    expect(() => hashSync("hello", "$2a$1Z$validsalthere")).toThrow(
+      "Illegal salt length: 9 != 16",
+    );
   });
 });

__tests__/helper.spec.ts

@@ -1,17 +1,61 @@
-import { expect, it } from "vitest";
+import { describe, expect, it } from "vitest";
 
-import { genSaltSync, getRounds, getSalt, hashSync } from "../src/index.js";
+import {
+  genSaltSync,
+  getRounds,
+  getSalt,
+  hashSync,
+  truncates,
+} from "../src/index.js";
 
-it("Get salt", () => {
-  const hash1 = hashSync("hello", genSaltSync());
-  const salt = getSalt(hash1);
-  const hash2 = hashSync("hello", salt);
+describe("getSalt", () => {
+  it("should work", () => {
+    const hash1 = hashSync("hello", genSaltSync());
+    const salt = getSalt(hash1);
+    const hash2 = hashSync("hello", salt);
 
-  expect(hash1).toEqual(hash2);
+    expect(hash1).toEqual(hash2);
+  });
+
+  it("should throw error for invalid argument types", () => {
+    // @ts-expect-error: error type check
+    expect(() => getSalt(123)).toThrow("Illegal arguments: number");
+    // @ts-expect-error: error type check
+    expect(() => getSalt(null)).toThrow("Illegal arguments: object");
+  });
+
+  it("should throw error for invalid hash length", () => {
+    expect(() => getSalt("invalid")).toThrow("Illegal hash length: 7 != 60");
+    expect(() => getSalt("short")).toThrow("Illegal hash length: 5 != 60");
+  });
+});
+
+describe("getRounds", () => {
+  it("should work", () => {
+    const hash1 = hashSync("hello", genSaltSync());
+
+    expect(getRounds(hash1)).toBe(10);
+  });
+
+  it("should throw error for invalid argument types", () => {
+    // @ts-expect-error: error type check
+    expect(() => getRounds(123)).toThrow("Illegal arguments: number");
+    // @ts-expect-error: error type check
+    expect(() => getRounds(null)).toThrow("Illegal arguments: object");
+  });
 });
 
-it("Get rounds", () => {
-  const hash1 = hashSync("hello", genSaltSync());
+describe("truncates", () => {
+  it("should work", () => {
+    expect(truncates("hello")).toBe(false);
+    expect(truncates("a".repeat(72))).toBe(false);
+    expect(truncates("a".repeat(73))).toBe(true);
+  });
 
-  expect(getRounds(hash1)).toBe(10);
+  it("should throw error for invalid argument types", () => {
+    // @ts-expect-error: error type check
+    expect(() => truncates(123)).toThrow("Illegal arguments: number");
+    // @ts-expect-error: error type check
+    expect(() => truncates(null)).toThrow("Illegal arguments: object");
+  });
 });

__tests__/nextTick.spec.ts

@@ -0,0 +1,23 @@
+import { describe, expect, it } from "vitest";
+
+import { nextTick } from "../src/nextTick/node.js";
+
+describe("nextTick", () => {
+  it("should work correctly", () =>
+    new Promise<void>((resolve) => {
+      let executed = false;
+
+      nextTick(() => {
+        executed = true;
+        expect(executed).toBe(true);
+        resolve();
+      });
+
+      expect(executed).toBe(false);
+    }));
+
+  it("should use setImmediate in Node.js", () => {
+    // Test that nextTick is using the correct function
+    expect(typeof nextTick).toBe("function");
+  });
+});

__tests__/progress.spec.ts

@@ -1,16 +1,18 @@
-import { expect, it } from "vitest";
+import { describe, expect, it } from "vitest";
 
 import { genSaltSync, hash } from "../src/index.js";
 
-it("Should show progress", () => {
-  const salt = genSaltSync(12);
+describe("hash progress callback", () => {
+  it("should show progress", async () => {
+    const salt = genSaltSync(12);
 
-  const progress: number[] = [];
+    const progress: number[] = [];
 
-  return hash("hello world", salt, (percent) => {
-    progress.push(percent);
-  }).then((hash) => {
-    expect(typeof hash === "string").toBe(true);
+    const result = await hash("hello world", salt, (percent) => {
+      progress.push(percent);
+    });
+
+    expect(typeof result === "string").toBe(true);
     expect(progress.length).toBeGreaterThan(2);
     expect(progress[0]).toBe(0);
     expect(progress[progress.length - 1]).toBe(1);