@musecat/functionkit 1.1.0 → 1.2.1

package/tests/cookie/cookie.test.ts

@@ -1,192 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
-import {
-	clearAllClientCookies,
-	clearClientCookie,
-	getClientCookie,
-	setClientCookie,
-} from "@/packages/cookie/cookie.shared";
-import { parseClientCookieNames } from "@/packages/cookie/cookieNames.shared";
-
-describe("cookie module", () => {
-	beforeEach(() => {
-		// Reset cookies
-		Object.defineProperty(document, "cookie", {
-			writable: true,
-			value: "",
-		});
-
-		// Mock window location
-		Object.defineProperty(window, "location", {
-			writable: true,
-			value: { hostname: "example.com", pathname: "/test/path" },
-		});
-	});
-
-	afterEach(() => {
-		vi.restoreAllMocks();
-	});
-
-	describe("parseClientCookieNames", () => {
-		test("parses cookie string correctly", () => {
-			const result = parseClientCookieNames("foo=bar; baz=qux; ; empty=");
-			expect(result).toEqual(["foo", "baz", "empty"]);
-		});
-
-		test("returns empty array for empty string", () => {
-			expect(parseClientCookieNames("")).toEqual([]);
-		});
-	});
-
-	describe("getClientCookie", () => {
-		test("returns cookie value if it exists", () => {
-			document.cookie = "foo=bar; baz=qux";
-			expect(getClientCookie("foo")).toBe("bar");
-			expect(getClientCookie("baz")).toBe("qux");
-		});
-
-		test("skips cookies with empty name when parsing", () => {
-			document.cookie = "=value; foo=bar";
-			expect(getClientCookie("foo")).toBe("bar");
-		});
-
-		test("returns undefined if cookie does not exist", () => {
-			document.cookie = "foo=bar";
-			expect(getClientCookie("missing")).toBeUndefined();
-		});
-
-		test("handles undefined document", () => {
-			const originalDocument = global.document;
-			// @ts-expect-error
-			delete global.document;
-
-			expect(getClientCookie("foo")).toBeUndefined();
-
-			global.document = originalDocument;
-		});
-	});
-
-	describe("setClientCookie", () => {
-		test("handles undefined document in setClientCookie", () => {
-			const origDocument = global.document;
-			// @ts-expect-error
-			delete global.document;
-			setClientCookie("foo", "bar");
-			global.document = origDocument;
-		});
-
-		test("parseClientCookie handles malformed entries", () => {
-			const result = parseClientCookieNames("=value; key");
-			expect(result).toEqual(["key"]);
-		});
-
-		test("clearAllClientCookies handles empty cookie name", () => {
-			const mockDoc = { cookie: "=1;;" };
-			const entries = clearAllClientCookies({ documentRef: mockDoc as any });
-			expect(Array.isArray(entries)).toBe(true);
-		});
-
-		test("clearAllClientCookies skips entries with empty name", () => {
-			const mockDoc = { cookie: "a=1;;b=2" };
-			const entries = clearAllClientCookies({ documentRef: mockDoc as any });
-			// Entries with empty names should be skipped in the loop
-			expect(entries).toEqual(["a", "b"]);
-		});
-
-		test("setClientCookie with days=0 does not add expires", () => {
-			setClientCookie("foo", "bar", 0);
-			expect(document.cookie).toBe("foo=bar; path=/");
-		});
-
-		test("sets cookie with name and value", () => {
-			setClientCookie("foo", "bar");
-			expect(document.cookie).toBe("foo=bar; path=/");
-		});
-
-		test("sets cookie with days", () => {
-			vi.useFakeTimers();
-			vi.setSystemTime(new Date("2020-01-01T00:00:00Z"));
-
-			setClientCookie("foo", "bar", 7);
-
-			const expectedDate = new Date("2020-01-08T00:00:00Z").toUTCString();
-			expect(document.cookie).toBe(`foo=bar; expires=${expectedDate}; path=/`);
-
-			vi.useRealTimers();
-		});
-
-		test("encodes cookie value", () => {
-			setClientCookie("foo", "val ue;");
-			expect(document.cookie).toBe("foo=val%20ue%3B; path=/");
-		});
-	});
-
-	describe("clearClientCookie", () => {
-		test("clears cookie with default options", () => {
-			document.cookie = "foo=bar";
-			clearClientCookie("foo");
-			expect(document.cookie).toBe(
-				"foo=; expires=Thu, 01 Jan 1970 00:00:00 GMT; path=/; domain=example.com;",
-			);
-		});
-
-		test("clears cookie with custom options", () => {
-			const mockDoc = { cookie: "" };
-			clearClientCookie("foo", {
-				hostname: "custom.com",
-				path: "/custom",
-				documentRef: mockDoc,
-			});
-			expect(mockDoc.cookie).toBe(
-				"foo=; expires=Thu, 01 Jan 1970 00:00:00 GMT; path=/custom; domain=custom.com;",
-			);
-		});
-	});
-
-	describe("clearAllClientCookies", () => {
-		test("clears all cookies based on documentRef.cookie", () => {
-			const mockDoc = { cookie: "a=1; b=2" };
-			const entries = clearAllClientCookies({ documentRef: mockDoc });
-
-			expect(entries).toEqual(["a", "b"]);
-			expect(mockDoc.cookie).toContain(
-				"b=; expires=Thu, 01 Jan 1970 00:00:00 GMT; path=/test/path; domain=com;",
-			);
-		});
-
-		test("clears cookies using cookieStore if provided", async () => {
-			const cookieStore = { delete: vi.fn().mockResolvedValue(undefined) };
-			const mockDoc = { cookie: "a=1; b=2" };
-
-			const entries = clearAllClientCookies({
-				documentRef: mockDoc,
-				cookieStore,
-			});
-
-			expect(entries).toEqual(["a", "b"]);
-			expect(cookieStore.delete).toHaveBeenCalledWith("a");
-			expect(cookieStore.delete).toHaveBeenCalledWith("b");
-		});
-
-		test("clears cookies from root path when includeRoot is true", () => {
-			const mockDoc = { cookie: "a=1" };
-			clearAllClientCookies({ documentRef: mockDoc, includeRoot: true });
-
-			// The function iterates and updates document.cookie, so it will contain the last assignment.
-			// With paths ["/", "/test/path"] and domain "example.com"
-			expect(mockDoc.cookie).toContain(
-				"a=; expires=Thu, 01 Jan 1970 00:00:00 GMT; path=/test/path; domain=com;",
-			);
-		});
-
-		test("uses provided cookieString instead of documentRef.cookie", () => {
-			const mockDoc = { cookie: "a=1" };
-			const entries = clearAllClientCookies({
-				documentRef: mockDoc,
-				cookieString: "x=1; y=2",
-			});
-
-			expect(entries).toEqual(["x", "y"]);
-			expect(mockDoc.cookie).toContain("y=;");
-		});
-	});
-});

package/tests/datetime/datetime.test.ts

@@ -1,461 +0,0 @@
-import { describe, expect, test, vi } from "vitest";
-import {
-	formatClientDate,
-	formatClientDateTime,
-	formatClientRelative,
-	formatClientTime,
-} from "@/packages/datetime/dateTime.client";
-import {
-	formatServerDate,
-	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", () => {
-		describe("normalizeAppLocale", () => {
-			test("normalizes kr/ko", () => {
-				expect(normalizeAppLocale("kr")).toBe("kr");
-				expect(normalizeAppLocale("ko")).toBe("kr");
-			});
-			test("normalizes jp/ja", () => {
-				expect(normalizeAppLocale("jp")).toBe("jp");
-				expect(normalizeAppLocale("ja")).toBe("jp");
-			});
-			test("defaults to en", () => {
-				expect(normalizeAppLocale("fr")).toBe("en");
-				expect(normalizeAppLocale(undefined)).toBe("en");
-			});
-		});
-
-		describe("toIntlLocale", () => {
-			test("maps to correct intl locales", () => {
-				expect(toIntlLocale("kr")).toBe("ko-KR");
-				expect(toIntlLocale("jp")).toBe("ja-JP");
-				expect(toIntlLocale("en")).toBe("en-US");
-			});
-		});
-
-		describe("toDate", () => {
-			test("returns Date object for valid inputs", () => {
-				expect(toDate(new Date("2020-01-01"))).toBeInstanceOf(Date);
-				expect(toDate("2020-01-01")).toBeInstanceOf(Date);
-				expect(toDate(1577836800000)).toBeInstanceOf(Date);
-			});
-			test("returns null for invalid inputs", () => {
-				expect(toDate("invalid")).toBeNull();
-				expect(toDate(new Date("invalid"))).toBeNull();
-			});
-		});
-
-		describe("toUtcMidnight", () => {
-			test("converts to UTC midnight", () => {
-				const date = new Date("2020-01-01T15:30:00Z");
-				const utcDate = toUtcMidnight(date);
-				expect(utcDate.toISOString()).toBe("2020-01-01T00:00:00.000Z");
-			});
-		});
-
-		describe("parseUtcDateInput", () => {
-			test("parses YYYY-MM-DD string to UTC midnight", () => {
-				const result = parseUtcDateInput("2020-05-10");
-				expect(result?.toISOString()).toBe("2020-05-10T00:00:00.000Z");
-			});
-			test("parses Date object to UTC midnight", () => {
-				const result = parseUtcDateInput(new Date("2020-05-10T15:00:00Z"));
-				expect(result?.toISOString()).toBe("2020-05-10T00:00:00.000Z");
-			});
-			test("uses fallback", () => {
-				const result = parseUtcDateInput("invalid", "2020-01-01T00:00:00Z");
-				expect(result?.toISOString()).toBe("2020-01-01T00:00:00.000Z");
-			});
-			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");
-			});
-		});
-
-		describe("getUtcWeekdayIndex", () => {
-			test("returns correct weekday index", () => {
-				expect(getUtcWeekdayIndex(new Date("2020-01-05T00:00:00Z"))).toBe(0); // Sunday
-				expect(getUtcWeekdayIndex(new Date("2020-01-06T00:00:00Z"))).toBe(1); // Monday
-			});
-		});
-
-		describe("addUtcDays", () => {
-			test("adds days to date", () => {
-				const result = addUtcDays(new Date("2020-01-01T00:00:00Z"), 5);
-				expect(result.toISOString()).toBe("2020-01-06T00:00:00.000Z");
-			});
-			test("handles negative days", () => {
-				const result = addUtcDays(new Date("2020-01-05T00:00:00Z"), -2);
-				expect(result.toISOString()).toBe("2020-01-03T00:00:00.000Z");
-			});
-		});
-
-		describe("formatters", () => {
-			const testDate = new Date("2020-05-10T15:30:45Z"); // UTC time
-
-			test("formatLongDate", () => {
-				expect(formatLongDate(testDate, "kr", "UTC")).toBe("2020년 5월 10일");
-				expect(formatLongDate(testDate, "jp", "UTC")).toBe("2020年5月10日");
-				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)).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-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(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",
-					isRelative: true,
-				});
-				expect(formatRelativeText(30000, "kr")).toEqual({
-					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,
-				});
-			});
-		});
-
-		describe("formatRemainingText", () => {
-			test("formats remaining time", () => {
-				expect(formatRemainingText(0)).toBe("Closed");
-				expect(formatRemainingText(0, "kr")).toBe("마감됨");
-				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(3665000, "kr")).toBe("1시간 1분 남음");
-				expect(formatRemainingText(90065000, "jp")).toBe("あと1日1時間");
-			});
-			test("without suffix", () => {
-				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,
-				});
-			});
-		});
-	});
-
-	describe("client/server wrappers", () => {
-		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, { 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", () => {
-			const now = new Date("2020-05-10T15:35:45Z"); // 5 mins later
-			expect(formatClientRelative(testDate, { now, locale: "kr" })).toEqual({
-				text: "5분 전",
-				isRelative: true,
-			});
-			expect(formatServerRelative(testDate, { now, locale: "kr" })).toEqual({
-				text: "5분 전",
-				isRelative: true,
-			});
-
-			const farFutureNow = new Date("2020-05-20T15:30:45Z"); // 10 days later
-			expect(
-				formatClientRelative(testDate, {
-					now: farFutureNow,
-					locale: "kr",
-					fallbackDatePreset: "dot",
-					maxRelativeDays: 7,
-				}),
-			).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,43 +0,0 @@
-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");
-	});
-});