@musecat/functionkit 1.0.2 → 1.1.0

package/tests/datetime/datetime.test.ts

@@ -1,33 +1,33 @@
-import { describe, test, expect } from "vitest";
-import {
-	normalizeAppLocale,
-	toIntlLocale,
-	toDate,
-	toUtcMidnight,
-	parseUtcDateInput,
-	formatUtcDateKey,
-	getUtcWeekdayIndex,
-	addUtcDays,
-	formatLongDate,
-	formatDotDate,
-	format24HourTime,
-	formatKoreanTime,
-	formatTwelveHourTime,
-	formatRelativeText,
-	formatRemainingText,
-} from "@/packages/datetime/dateTime.shared";
+import { describe, expect, test, vi } from "vitest";
 import {
 	formatClientDate,
-	formatClientTime,
 	formatClientDateTime,
 	formatClientRelative,
+	formatClientTime,
 } from "@/packages/datetime/dateTime.client";
 import {
 	formatServerDate,
-	formatServerTime,
 	formatServerDateTime,
 	formatServerRelative,
+	formatServerTime,
 } from "@/packages/datetime/dateTime.server";
+import {
+	addUtcDays,
+	format24HourTime,
+	formatDotDate,
+	formatKoreanTime,
+	formatLongDate,
+	formatRelativeText,
+	formatRemainingText,
+	formatTwelveHourTime,
+	formatUtcDateKey,
+	getUtcWeekdayIndex,
+	normalizeAppLocale,
+	parseUtcDateInput,
+	toDate,
+	toIntlLocale,
+	toUtcMidnight,
+} from "@/packages/datetime/dateTime.shared";
 
 describe("datetime module", () => {
 	describe("shared", () => {
@@ -90,13 +90,23 @@ describe("datetime module", () => {
 			test("returns null if both invalid", () => {
 				expect(parseUtcDateInput("invalid", "invalid")).toBeNull();
 			});
+
+			test("returns null when no fallback provided", () => {
+				expect(parseUtcDateInput("invalid")).toBeNull();
+			});
+
+			test("handles undefined value", () => {
+				expect(parseUtcDateInput(undefined)).toBeNull();
+			});
+
+			test("handles null value", () => {
+				expect(parseUtcDateInput(null)).toBeNull();
+			});
 		});
 
 		describe("formatUtcDateKey", () => {
 			test("formats date to YYYY-MM-DD", () => {
-				expect(formatUtcDateKey(new Date("2020-05-05T00:00:00Z"))).toBe(
-					"2020-05-05",
-				);
+				expect(formatUtcDateKey(new Date("2020-05-05T00:00:00Z"))).toBe("2020-05-05");
 			});
 		});
 
@@ -127,33 +137,63 @@ describe("datetime module", () => {
 				expect(formatLongDate(testDate, "en", "UTC")).toContain("2020");
 			});
 
+			test("handles missing date/time parts gracefully", () => {
+				const spy = vi.spyOn(Intl.DateTimeFormat.prototype, "formatToParts").mockReturnValue([]);
+				try {
+					expect(formatLongDate(testDate, "kr", "UTC")).toBe("0000년 0월 0일");
+					expect(format24HourTime(testDate)).toBe("00:00");
+				} finally {
+					spy.mockRestore();
+				}
+			});
+
 			test("formatDotDate", () => {
 				expect(formatDotDate(testDate, "UTC")).toBe("2020. 5. 10.");
 			});
 
 			test("format24HourTime", () => {
 				expect(format24HourTime(testDate, { timeZone: "UTC" })).toBe("15:30");
-				expect(
-					format24HourTime(testDate, { includeSeconds: true, timeZone: "UTC" }),
-				).toBe("15:30:45");
+				expect(format24HourTime(testDate, { includeSeconds: true, timeZone: "UTC" })).toBe(
+					"15:30:45",
+				);
+				expect(format24HourTime(testDate)).toBe("15:30");
 			});
 
 			test("formatKoreanTime", () => {
 				expect(formatKoreanTime(testDate, "UTC")).toBe("오후 3시 30분");
-				expect(formatKoreanTime(new Date("2020-05-10T09:15:00Z"), "UTC")).toBe(
-					"오전 9시 15분",
-				);
+				expect(formatKoreanTime(new Date("2020-05-10T09:15:00Z"), "UTC")).toBe("오전 9시 15분");
+				expect(formatKoreanTime(new Date("2020-05-10T00:30:00Z"), "UTC")).toBe("오전 12시 30분");
+				expect(formatKoreanTime(new Date("2020-05-10T12:30:00Z"), "UTC")).toBe("오후 12시 30분");
 			});
 
 			test("formatTwelveHourTime", () => {
 				expect(formatTwelveHourTime(testDate, "kr", "UTC")).toBe("오후 3:30");
-				expect(formatTwelveHourTime(testDate, "en", "UTC")).toMatch(
-					/3:30 (PM|pm)/,
-				);
+				expect(formatTwelveHourTime(new Date("2020-05-10T00:30:00Z"), "kr", "UTC")).toBe("오전 12:30");
+				expect(formatTwelveHourTime(new Date("2020-05-10T12:30:00Z"), "kr", "UTC")).toBe("오후 12:30");
+				expect(formatTwelveHourTime(testDate, "en", "UTC")).toMatch(/3:30 (PM|pm)/);
 			});
 		});
 
 		describe("formatRelativeText", () => {
+			test("formatRelativeUnit with singular count (1 second, 1 minute, etc)", () => {
+				expect(formatRelativeText(1000, "en")).toEqual({
+					text: "1 second ago",
+					isRelative: true,
+				});
+				expect(formatRelativeText(60000, "en")).toEqual({
+					text: "1 minute ago",
+					isRelative: true,
+				});
+				expect(formatRelativeText(3600000, "en")).toEqual({
+					text: "1 hour ago",
+					isRelative: true,
+				});
+				expect(formatRelativeText(86400000, "en")).toEqual({
+					text: "1 day ago",
+					isRelative: true,
+				});
+			});
+
 			test("formats seconds", () => {
 				expect(formatRelativeText(30000, "en")).toEqual({
 					text: "30 seconds ago",
@@ -163,24 +203,52 @@ describe("datetime module", () => {
 					text: "30초 전",
 					isRelative: true,
 				});
+				expect(formatRelativeText(30000, "jp")).toEqual({
+					text: "30秒前",
+					isRelative: true,
+				});
 			});
 			test("formats minutes", () => {
 				expect(formatRelativeText(120000, "en")).toEqual({
 					text: "2 minutes ago",
 					isRelative: true,
 				});
+				expect(formatRelativeText(120000, "kr")).toEqual({
+					text: "2분 전",
+					isRelative: true,
+				});
+				expect(formatRelativeText(120000, "jp")).toEqual({
+					text: "2分前",
+					isRelative: true,
+				});
 			});
 			test("formats hours", () => {
 				expect(formatRelativeText(7200000, "en")).toEqual({
 					text: "2 hours ago",
 					isRelative: true,
 				});
+				expect(formatRelativeText(7200000, "kr")).toEqual({
+					text: "2시간 전",
+					isRelative: true,
+				});
+				expect(formatRelativeText(7200000, "jp")).toEqual({
+					text: "2時間前",
+					isRelative: true,
+				});
 			});
 			test("formats days", () => {
 				expect(formatRelativeText(172800000, "en")).toEqual({
 					text: "2 days ago",
 					isRelative: true,
 				});
+				expect(formatRelativeText(172800000, "kr")).toEqual({
+					text: "2일 전",
+					isRelative: true,
+				});
+				expect(formatRelativeText(172800000, "jp")).toEqual({
+					text: "2日前",
+					isRelative: true,
+				});
 			});
 		});
 
@@ -191,16 +259,64 @@ describe("datetime module", () => {
 				expect(formatRemainingText(0, "jp")).toBe("締切終了");
 
 				expect(formatRemainingText(1000, "en")).toBe("1 second left");
-				expect(formatRemainingText(65000, "en")).toBe(
-					"1 minute 5 seconds left",
-				);
+				expect(formatRemainingText(65000, "en")).toBe("1 minute 5 seconds left");
 				expect(formatRemainingText(3665000, "kr")).toBe("1시간 1분 남음");
 				expect(formatRemainingText(90065000, "jp")).toBe("あと1日1時間");
 			});
 			test("without suffix", () => {
-				expect(formatRemainingText(1000, "en", { includeSuffix: false })).toBe(
-					"1 second",
-				);
+				expect(formatRemainingText(1000, "en", { includeSuffix: false })).toBe("1 second");
+			});
+
+			test("remaining time less than 1 second defaults to 1 second", () => {
+				expect(formatRemainingText(500, "en")).toBe("1 second left");
+			});
+
+			test("formatRemainingText jp locale with no suffix", () => {
+				expect(formatRemainingText(3665000, "jp", { includeSuffix: false })).toBe("1時間1分");
+			});
+
+			test("formatRemainingUnit for kr locale covers all units", () => {
+				expect(formatRemainingText(1000, "kr")).toBe("1초 남음");
+				expect(formatRemainingText(60000, "kr")).toBe("1분 남음");
+				expect(formatRemainingText(3600000, "kr")).toBe("1시간 남음");
+				expect(formatRemainingText(86400000, "kr")).toBe("1일 남음");
+			});
+
+			test("formatRemainingUnit for jp locale", () => {
+				expect(formatRemainingText(1000, "jp")).toBe("あと1秒");
+				expect(formatRemainingText(60000, "jp")).toBe("あと1分");
+				expect(formatRemainingText(3600000, "jp")).toBe("あと1時間");
+				expect(formatRemainingText(86400000, "jp")).toBe("あと1日");
+			});
+
+			test("formatRemainingUnit for en locale covers all units", () => {
+				expect(formatRemainingText(1000, "en")).toBe("1 second left");
+				expect(formatRemainingText(60000, "en")).toBe("1 minute left");
+				expect(formatRemainingText(3600000, "en")).toBe("1 hour left");
+				expect(formatRemainingText(86400000, "en")).toBe("1 day left");
+			});
+
+			test("formatLongDate with undefined locale defaults to en", () => {
+				expect(formatLongDate(new Date("2020-05-10T15:00:00Z"), undefined)).toContain("2020");
+			});
+
+			test("formatRelativeText with jp locale", () => {
+				expect(formatRelativeText(30000, "jp")).toEqual({
+					text: "30秒前",
+					isRelative: true,
+				});
+				expect(formatRelativeText(120000, "jp")).toEqual({
+					text: "2分前",
+					isRelative: true,
+				});
+				expect(formatRelativeText(7200000, "jp")).toEqual({
+					text: "2時間前",
+					isRelative: true,
+				});
+				expect(formatRelativeText(172800000, "jp")).toEqual({
+					text: "2日前",
+					isRelative: true,
+				});
 			});
 		});
 	});
@@ -209,15 +325,41 @@ describe("datetime module", () => {
 		const testDate = new Date("2020-05-10T15:30:45Z");
 
 		test("formatClientDateTime / formatServerDateTime", () => {
-			expect(formatClientDateTime(testDate, { timeZone: "UTC" })).toBe(
-				"May 10, 2020 15:30",
+			expect(formatClientDateTime(testDate, { timeZone: "UTC" })).toBe("May 10, 2020 15:30");
+			expect(formatClientDateTime(testDate, { locale: "kr", timeZone: "UTC" })).toBe(
+				"2020년 5월 10일 15:30",
 			);
-			expect(
-				formatClientDateTime(testDate, { locale: "kr", timeZone: "UTC" }),
-			).toBe("2020년 5월 10일 15:30");
-			expect(
-				formatServerDateTime(testDate, { locale: "kr", timeZone: "UTC" }),
-			).toBe("2020년 5월 10일 15:30");
+			expect(formatServerDateTime(testDate, { locale: "kr", timeZone: "UTC" })).toBe(
+				"2020년 5월 10일 15:30",
+			);
+		});
+
+		test("formatClientTime with various presets", () => {
+			expect(formatClientTime(testDate, { preset: "ko", timeZone: "UTC" })).toBe("오후 3시 30분");
+			expect(formatClientTime(testDate, { preset: "12h", locale: "en", timeZone: "UTC" })).toMatch(
+				/3:30 (PM|pm)/,
+			);
+			expect(formatClientTime(testDate, { preset: "24h-second", timeZone: "UTC" })).toBe(
+				"15:30:45",
+			);
+		});
+
+		test("formatServerTime with various presets", () => {
+			expect(formatServerTime(testDate, { preset: "ko", timeZone: "UTC" })).toBe("오후 3시 30분");
+			expect(formatServerTime(testDate, { preset: "12h", locale: "en", timeZone: "UTC" })).toMatch(
+				/3:30 (PM|pm)/,
+			);
+			expect(formatServerTime(testDate, { preset: "24h-second", timeZone: "UTC" })).toBe(
+				"15:30:45",
+			);
+		});
+
+		test("formatClientTime returns empty for invalid date", () => {
+			expect(formatClientTime("invalid", { preset: "24h-minute" })).toBe("");
+		});
+
+		test("formatClientDateTime returns only date or time when one is empty", () => {
+			expect(formatClientDateTime("invalid", {})).toBe("");
 		});
 
 		test("formatClientRelative / formatServerRelative", () => {
@@ -242,6 +384,75 @@ describe("datetime module", () => {
 			).toEqual({ text: formatDotDate(testDate), isRelative: false });
 		});
 
+		test("formatClientRelative returns empty when given invalid date", () => {
+			expect(formatClientRelative("invalid", {})).toEqual({ text: "", isRelative: false });
+		});
+
+		test("formatClientRelative beyond maxRelative without fallbackDatePreset uses dot default", () => {
+			const oldDate = new Date("2020-01-01T00:00:00Z");
+			const now = new Date("2020-05-10T00:00:00Z");
+			const result = formatClientRelative(oldDate, { now, maxRelativeDays: 30, locale: "en" });
+			expect(result.isRelative).toBe(false);
+			expect(result.text).toContain("2020");
+		});
+
+		test("formatClientRelative returns empty when now is invalid", () => {
+			expect(formatClientRelative(testDate, { now: "invalid" })).toEqual({
+				text: "",
+				isRelative: false,
+			});
+		});
+
+		test("formatServerRelative returns empty when given invalid date", () => {
+			expect(formatServerRelative("invalid", {})).toEqual({ text: "", isRelative: false });
+		});
+
+		test("formatServerRelative returns empty when now is invalid", () => {
+			expect(formatServerRelative(testDate, { now: "invalid" })).toEqual({
+				text: "",
+				isRelative: false,
+			});
+		});
+
+		test("formatServerRelative beyond maxRelativeDays with fallback preset", () => {
+			const oldDate = new Date("2020-01-01T00:00:00Z");
+			const now = new Date("2020-05-10T00:00:00Z");
+			const result = formatServerRelative(oldDate, {
+				now,
+				maxRelativeDays: 30,
+				fallbackDatePreset: "long",
+				locale: "en",
+			});
+			expect(result.isRelative).toBe(false);
+			expect(typeof result.text).toBe("string");
+		});
+
+		test("formatServerRelative beyond maxRelative without fallbackDatePreset", () => {
+			const oldDate = new Date("2020-01-01T00:00:00Z");
+			const now = new Date("2020-05-10T00:00:00Z");
+			const result = formatServerRelative(oldDate, { now, maxRelativeDays: 30, locale: "en" });
+			expect(result.isRelative).toBe(false);
+			expect(result.text).toContain("2020");
+		});
+
+		test("formatServerDate returns empty for invalid date", () => {
+			expect(formatServerDate("invalid", { preset: "dot" })).toBe("");
+		});
+
+		test("formatServerDate with dot preset", () => {
+			expect(formatServerDate(testDate, { preset: "dot", timeZone: "UTC" })).toBe("2020. 5. 10.");
+		});
+
+		test("formatServerDate with long preset", () => {
+			expect(formatServerDate(testDate, { preset: "long", locale: "kr", timeZone: "UTC" })).toBe(
+				"2020년 5월 10일",
+			);
+		});
+
+		test("formatServerDateTime returns only date when time is empty", () => {
+			expect(formatServerDateTime("invalid", {})).toBe("");
+		});
+
 		test("handles invalid inputs gracefully", () => {
 			expect(formatClientDate("invalid", { preset: "long" })).toBe("");
 			expect(formatServerTime("invalid", { preset: "ko" })).toBe("");

package/tests/hooks/useAvoidKeyboard.test.ts

@@ -1,12 +1,43 @@
-import { describe, test, expect } from "vitest";
 import { renderHook } from "@testing-library/react";
+import { describe, expect, test } from "vitest";
 import { useAvoidKeyboard } from "@/packages/hooks/useAvoidKeyboard";
 
+import { useKeyboardHeight } from "@/packages/hooks/useKeyboardHeight";
+
+vi.mock("@/packages/hooks/useKeyboardHeight");
+
 describe("useAvoidKeyboard", () => {
+	beforeEach(() => {
+		vi.mocked(useKeyboardHeight).mockReturnValue({ keyboardHeight: 0 });
+	});
+
 	test("returns style object", () => {
 		const { result } = renderHook(() => useAvoidKeyboard());
 		expect(result.current.style).toBeDefined();
 		expect(result.current.style.transform).toBeUndefined();
 		expect(result.current.style.transition).toContain("transform");
 	});
+
+	test("applies translateY when keyboard is raised", () => {
+		vi.mocked(useKeyboardHeight).mockReturnValue({ keyboardHeight: 300 });
+		const { result } = renderHook(() => useAvoidKeyboard());
+		expect(result.current.style.transform).toBe("translateY(-300px)");
+	});
+
+	test("uses safeAreaBottom when keyboardHeight is 0", () => {
+		const { result } = renderHook(() => useAvoidKeyboard({ safeAreaBottom: 20 }));
+		expect(result.current.style.transform).toBe("translateY(-20px)");
+	});
+
+	test("no transform when both keyboardHeight and safeAreaBottom are 0", () => {
+		const { result } = renderHook(() => useAvoidKeyboard());
+		expect(result.current.style.transform).toBeUndefined();
+	});
+
+	test("accepts custom transition values", () => {
+		const { result } = renderHook(() =>
+			useAvoidKeyboard({ transitionDuration: 300, transitionTimingFunction: "linear" }),
+		);
+		expect(result.current.style.transition).toBe("transform 300ms linear");
+	});
 });

package/tests/hooks/useCheckInvisible.test.ts

@@ -1,12 +1,24 @@
-import { describe, test, expect, vi } from "vitest";
-import { renderHook, act } from "@testing-library/react";
+import { act, renderHook } from "@testing-library/react";
+import { describe, expect, test, vi } from "vitest";
 import { useCheckInvisible } from "@/packages/hooks/useCheckInvisible";
 
 describe("useCheckInvisible", () => {
 	test("returns isInvisible false when element is visible", () => {
 		const el = document.createElement("div");
 		el.className = "test-section";
-		el.getBoundingClientRect = vi.fn(() => ({ top: 100, bottom: 300, left: 0, right: 100, width: 100, height: 200, x: 0, y: 100 }) as DOMRect);
+		el.getBoundingClientRect = vi.fn(
+			() =>
+				({
+					top: 100,
+					bottom: 300,
+					left: 0,
+					right: 100,
+					width: 100,
+					height: 200,
+					x: 0,
+					y: 100,
+				}) as DOMRect,
+		);
 		document.body.appendChild(el);
 
 		const { result } = renderHook(() => useCheckInvisible("test-section"));
@@ -14,14 +26,33 @@ describe("useCheckInvisible", () => {
 		document.body.removeChild(el);
 	});
 
+	test("returns isInvisible false when element is not found in DOM", () => {
+		const { result } = renderHook(() => useCheckInvisible("non-existent"));
+		expect(result.current.isInvisible).toBe(false);
+	});
+
 	test("returns isInvisible true when element is scrolled above viewport", () => {
 		const el = document.createElement("div");
 		el.className = "test-section";
-		el.getBoundingClientRect = vi.fn(() => ({ top: -50, bottom: 150, left: 0, right: 100, width: 100, height: 200, x: 0, y: -50 }) as DOMRect);
+		el.getBoundingClientRect = vi.fn(
+			() =>
+				({
+					top: -50,
+					bottom: 150,
+					left: 0,
+					right: 100,
+					width: 100,
+					height: 200,
+					x: 0,
+					y: -50,
+				}) as DOMRect,
+		);
 		document.body.appendChild(el);
 
 		const { result } = renderHook(() => useCheckInvisible("test-section"));
-		act(() => { window.dispatchEvent(new Event("scroll")); });
+		act(() => {
+			window.dispatchEvent(new Event("scroll"));
+		});
 		expect(result.current.isInvisible).toBe(true);
 		document.body.removeChild(el);
 	});

package/tests/hooks/useCheckScroll.test.ts

@@ -1,5 +1,5 @@
-import { describe, test, expect } from "vitest";
-import { renderHook, act } from "@testing-library/react";
+import { act, renderHook } from "@testing-library/react";
+import { describe, expect, test } from "vitest";
 import { useCheckScroll } from "@/packages/hooks/useCheckScroll";
 
 describe("useCheckScroll", () => {

package/tests/hooks/useClientDateTime.test.ts

@@ -1,12 +1,10 @@
-import { describe, test, expect } from "vitest";
 import { renderHook } from "@testing-library/react";
+import { describe, expect, test } from "vitest";
 import { useClientDateTime } from "@/packages/hooks/useClientDateTime";
 
 describe("useClientDateTime", () => {
 	test("returns ready state and formatted text", () => {
-		const { result } = renderHook(() =>
-			useClientDateTime("2024-06-15", { locale: "ko" }),
-		);
+		const { result } = renderHook(() => useClientDateTime("2024-06-15", { locale: "ko" }));
 		expect(result.current.ready).toBe(true);
 		expect(result.current.text).toBeTruthy();
 		expect(result.current.date).toBeInstanceOf(Date);

package/tests/hooks/useDebounce.test.ts

@@ -1,10 +1,14 @@
-import { describe, test, expect, vi, beforeEach, afterEach } from "vitest";
 import { renderHook } from "@testing-library/react";
+import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
 import { debounce, useDebounce } from "@/packages/hooks/useDebounce";
 
 describe("debounce (standalone)", () => {
-	beforeEach(() => { vi.useFakeTimers(); });
-	afterEach(() => { vi.useRealTimers(); });
+	beforeEach(() => {
+		vi.useFakeTimers();
+	});
+	afterEach(() => {
+		vi.useRealTimers();
+	});
 
 	test("trailing: calls function after delay", () => {
 		const fn = vi.fn();
@@ -57,8 +61,12 @@ describe("debounce (standalone)", () => {
 });
 
 describe("useDebounce", () => {
-	beforeEach(() => { vi.useFakeTimers(); });
-	afterEach(() => { vi.useRealTimers(); });
+	beforeEach(() => {
+		vi.useFakeTimers();
+	});
+	afterEach(() => {
+		vi.useRealTimers();
+	});
 
 	test("returns a debounced function", () => {
 		const fn = vi.fn();
@@ -68,4 +76,21 @@ describe("useDebounce", () => {
 		vi.advanceTimersByTime(100);
 		expect(fn).toHaveBeenCalledOnce();
 	});
+
+	test("works with leading: true", () => {
+		const fn = vi.fn();
+		const { result } = renderHook(() => useDebounce(fn, 100, { leading: true }));
+		result.current();
+		expect(fn).toHaveBeenCalledOnce();
+		vi.advanceTimersByTime(100);
+		expect(fn).toHaveBeenCalledTimes(1);
+	});
+
+	test("works with trailing: false", () => {
+		const fn = vi.fn();
+		const { result } = renderHook(() => useDebounce(fn, 100, { trailing: false }));
+		result.current();
+		vi.advanceTimersByTime(100);
+		expect(fn).not.toHaveBeenCalled();
+	});
 });

package/tests/hooks/useDebouncedCallback.test.ts

@@ -1,33 +1,62 @@
-import { describe, test, expect, vi, beforeEach, afterEach } from "vitest";
-import { renderHook, act } from "@testing-library/react";
+import { act, renderHook } from "@testing-library/react";
+import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
 import { useDebouncedCallback } from "@/packages/hooks/useDebouncedCallback";
 
 describe("useDebouncedCallback", () => {
-	beforeEach(() => { vi.useFakeTimers(); });
-	afterEach(() => { vi.useRealTimers(); });
+	beforeEach(() => {
+		vi.useFakeTimers();
+	});
+	afterEach(() => {
+		vi.useRealTimers();
+	});
 
 	test("debounces onChange calls", () => {
 		const onChange = vi.fn();
-		const { result } = renderHook(() =>
-			useDebouncedCallback({ onChange, timeThreshold: 100 }),
-		);
+		const { result } = renderHook(() => useDebouncedCallback({ onChange, timeThreshold: 100 }));
 
-		act(() => { result.current(true); });
+		act(() => {
+			result.current(true);
+		});
 		vi.advanceTimersByTime(100);
 		expect(onChange).toHaveBeenCalledWith(true);
 	});
 
-	test("skips duplicate value", () => {
+	test("works with leading: true", () => {
 		const onChange = vi.fn();
 		const { result } = renderHook(() =>
-			useDebouncedCallback({ onChange, timeThreshold: 100 }),
+			useDebouncedCallback({ onChange, timeThreshold: 100, leading: true }),
 		);
+		act(() => {
+			result.current(true);
+		});
+		expect(onChange).toHaveBeenCalledOnce();
+	});
+
+	test("works with trailing: false", () => {
+		const onChange = vi.fn();
+		const { result } = renderHook(() =>
+			useDebouncedCallback({ onChange, timeThreshold: 100, trailing: false }),
+		);
+		act(() => {
+			result.current(true);
+		});
+		vi.advanceTimersByTime(100);
+		expect(onChange).not.toHaveBeenCalled();
+	});
+
+	test("skips duplicate value", () => {
+		const onChange = vi.fn();
+		const { result } = renderHook(() => useDebouncedCallback({ onChange, timeThreshold: 100 }));
 
-		act(() => { result.current(true); });
+		act(() => {
+			result.current(true);
+		});
 		vi.advanceTimersByTime(100);
 		expect(onChange).toHaveBeenCalledTimes(1);
 
-		act(() => { result.current(true); });
+		act(() => {
+			result.current(true);
+		});
 		vi.advanceTimersByTime(100);
 		expect(onChange).toHaveBeenCalledTimes(1);
 	});