@musecat/functionkit 1.0.2 → 1.1.0

package/tests/hooks/usePreservedReference.test.ts

@@ -1,35 +1,42 @@
-import { describe, test, expect, vi } from "vitest";
 import { renderHook } from "@testing-library/react";
+import { describe, expect, test } from "vitest";
 import { usePreservedReference } from "@/packages/hooks/usePreservedReference";
 
 describe("usePreservedReference", () => {
 	test("returns same reference for deeply equal values", () => {
-		const { result, rerender } = renderHook(
-			({ val }) => usePreservedReference(val),
-			{ initialProps: { val: { a: 1, b: { c: [2, 3] } } } },
-		);
+		const { result, rerender } = renderHook(({ val }) => usePreservedReference(val), {
+			initialProps: { val: { a: 1, b: { c: [2, 3] } } },
+		});
 		const first = result.current;
 		rerender({ val: { a: 1, b: { c: [2, 3] } } });
 		expect(result.current).toBe(first);
 	});
 
 	test("returns new reference for different values", () => {
-		const { result, rerender } = renderHook(
-			({ val }) => usePreservedReference(val),
-			{ initialProps: { val: { a: 1 } } },
-		);
+		const { result, rerender } = renderHook(({ val }) => usePreservedReference(val), {
+			initialProps: { val: { a: 1 } },
+		});
 		const first = result.current;
 		rerender({ val: { a: 2 } });
 		expect(result.current).not.toBe(first);
 	});
 
 	test("accepts custom comparator", () => {
+		const { result, rerender } = renderHook(({ val }) => usePreservedReference(val, () => true), {
+			initialProps: { val: { a: 1 } },
+		});
+		const first = result.current;
+		rerender({ val: { a: 999 } });
+		expect(result.current).toBe(first);
+	});
+
+	test("custom comparator returning false forces new reference", () => {
 		const { result, rerender } = renderHook(
-			({ val }) => usePreservedReference(val, () => true),
+			({ val }) => usePreservedReference(val, () => false),
 			{ initialProps: { val: { a: 1 } } },
 		);
 		const first = result.current;
-		rerender({ val: { a: 999 } });
-		expect(result.current).toBe(first);
+		rerender({ val: { a: 1 } });
+		expect(result.current).not.toBe(first);
 	});
 });

package/tests/hooks/useRefEffect.test.ts

@@ -1,5 +1,5 @@
-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 { useRefEffect } from "@/packages/hooks/useRefEffect";
 
 describe("useRefEffect", () => {
@@ -9,13 +9,46 @@ describe("useRefEffect", () => {
 		const { result } = renderHook(() => useRefEffect(callback, []));
 
 		const element = document.createElement("div");
-		act(() => { (result.current as (el: HTMLElement | null) => void)(element); });
+		act(() => {
+			(result.current as (el: HTMLElement | null) => void)(element);
+		});
 		expect(callback).toHaveBeenCalledWith(element);
 
-		act(() => { (result.current as (el: HTMLElement | null) => void)(null); });
+		act(() => {
+			(result.current as (el: HTMLElement | null) => void)(null);
+		});
 		expect(cleanup).toHaveBeenCalledOnce();
 	});
 
+	test("stores cleanup when callback returns a function", () => {
+		const cleanup = vi.fn();
+		const callback = vi.fn(() => cleanup);
+		const { result } = renderHook(() => useRefEffect(callback, []));
+
+		const element = document.createElement("div");
+		act(() => {
+			(result.current as (el: HTMLElement | null) => void)(element);
+		});
+
+		act(() => {
+			(result.current as (el: HTMLElement | null) => void)(null);
+		});
+		expect(cleanup).toHaveBeenCalled();
+	});
+
+	test("handles callback returning undefined (no cleanup)", () => {
+		const { result } = renderHook(() => useRefEffect(() => {}, []));
+
+		const element = document.createElement("div");
+		act(() => {
+			(result.current as (el: HTMLElement | null) => void)(element);
+		});
+		// Should not throw when cleanup is undefined
+		act(() => {
+			(result.current as (el: HTMLElement | null) => void)(null);
+		});
+	});
+
 	test("calls cleanup before setting new element", () => {
 		const cleanup = vi.fn();
 		const callback = vi.fn(() => cleanup);
@@ -23,8 +56,12 @@ describe("useRefEffect", () => {
 
 		const el1 = document.createElement("div");
 		const el2 = document.createElement("span");
-		act(() => { (result.current as (el: HTMLElement | null) => void)(el1); });
-		act(() => { (result.current as (el: HTMLElement | null) => void)(el2); });
+		act(() => {
+			(result.current as (el: HTMLElement | null) => void)(el1);
+		});
+		act(() => {
+			(result.current as (el: HTMLElement | null) => void)(el2);
+		});
 		expect(cleanup).toHaveBeenCalledOnce();
 	});
 });

package/tests/hooks/useRelativeDateTime.test.ts

@@ -1,17 +1,19 @@
-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 { useRelativeDateTime } from "@/packages/hooks/useRelativeDateTime";
 
 describe("useRelativeDateTime", () => {
-	beforeEach(() => { vi.useFakeTimers(); });
-	afterEach(() => { vi.useRealTimers(); });
+	beforeEach(() => {
+		vi.useFakeTimers();
+	});
+	afterEach(() => {
+		vi.useRealTimers();
+	});
 
 	test("returns relative time text", () => {
 		const now = Date.now();
 		const fiveMinAgo = new Date(now - 5 * 60 * 1000).toISOString();
-		const { result } = renderHook(() =>
-			useRelativeDateTime(fiveMinAgo, { locale: "ko" }),
-		);
+		const { result } = renderHook(() => useRelativeDateTime(fiveMinAgo, { locale: "ko" }));
 		expect(result.current.ready).toBe(true);
 		expect(result.current.isRelative).toBe(true);
 		expect(result.current.text).toBeTruthy();

package/tests/hooks/useTimeout.test.ts

@@ -1,10 +1,14 @@
-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 { useTimeout } from "@/packages/hooks/useTimeout";
 
 describe("useTimeout", () => {
-	beforeEach(() => { vi.useFakeTimers(); });
-	afterEach(() => { vi.useRealTimers(); });
+	beforeEach(() => {
+		vi.useFakeTimers();
+	});
+	afterEach(() => {
+		vi.useRealTimers();
+	});
 
 	test("calls callback after delay", () => {
 		const fn = vi.fn();
@@ -21,14 +25,48 @@ describe("useTimeout", () => {
 		expect(fn).not.toHaveBeenCalled();
 	});
 
+	test("clear cancels pending timeout", () => {
+		const fn = vi.fn();
+		const { result } = renderHook(() => useTimeout(fn, 100));
+
+		act(() => {
+			result.current.clear();
+		});
+		vi.advanceTimersByTime(100);
+		expect(fn).not.toHaveBeenCalled();
+	});
+
 	test("start and clear controls", () => {
 		const fn = vi.fn();
 		const { result } = renderHook(() => useTimeout(fn, 1000, { enabled: false }));
 		expect(result.current.isPending()).toBe(false);
-		act(() => { result.current.start(50); });
+		act(() => {
+			result.current.start(50);
+		});
 		expect(result.current.isPending()).toBe(true);
 		vi.advanceTimersByTime(50);
 		expect(fn).toHaveBeenCalledOnce();
 		expect(result.current.isPending()).toBe(false);
 	});
+
+	test("reset restarts the timeout", () => {
+		const fn = vi.fn();
+		const { result } = renderHook(() => useTimeout(fn, 500));
+		vi.advanceTimersByTime(200);
+		act(() => {
+			result.current.reset(100);
+		});
+		vi.advanceTimersByTime(100);
+		expect(fn).toHaveBeenCalledOnce();
+	});
+
+	test("start overrides default delay", () => {
+		const fn = vi.fn();
+		const { result } = renderHook(() => useTimeout(fn, 500, { enabled: false }));
+		act(() => {
+			result.current.start(50);
+		});
+		vi.advanceTimersByTime(50);
+		expect(fn).toHaveBeenCalledOnce();
+	});
 });

package/tests/hooks/useToggleState.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 { useToggleState } from "@/packages/hooks/useToggleState";
 
 describe("useToggleState", () => {
@@ -15,21 +15,29 @@ describe("useToggleState", () => {
 
 	test("setTrue sets value to true", () => {
 		const { result } = renderHook(() => useToggleState(false));
-		act(() => { result.current.setTrue(); });
+		act(() => {
+			result.current.setTrue();
+		});
 		expect(result.current.value).toBe(true);
 	});
 
 	test("setFalse sets value to false", () => {
 		const { result } = renderHook(() => useToggleState(true));
-		act(() => { result.current.setFalse(); });
+		act(() => {
+			result.current.setFalse();
+		});
 		expect(result.current.value).toBe(false);
 	});
 
 	test("toggle switches value", () => {
 		const { result } = renderHook(() => useToggleState(false));
-		act(() => { result.current.toggle(); });
+		act(() => {
+			result.current.toggle();
+		});
 		expect(result.current.value).toBe(true);
-		act(() => { result.current.toggle(); });
+		act(() => {
+			result.current.toggle();
+		});
 		expect(result.current.value).toBe(false);
 	});
 });

package/tests/hooks/useViewportHeight.test.ts

@@ -1,5 +1,5 @@
-import { describe, test, expect } from "vitest";
-import { renderHook } from "@testing-library/react";
+import { act, renderHook } from "@testing-library/react";
+import { describe, expect, test, vi } from "vitest";
 import { useViewportHeight } from "@/packages/hooks/useViewportHeight";
 
 describe("useViewportHeight", () => {
@@ -7,4 +7,26 @@ describe("useViewportHeight", () => {
 		const { result } = renderHook(() => useViewportHeight());
 		expect(result.current.height).toBeGreaterThanOrEqual(0);
 	});
+
+	test("updates height on window resize", () => {
+		const { result } = renderHook(() => useViewportHeight());
+
+		act(() => {
+			window.innerHeight = 500;
+			window.dispatchEvent(new Event("resize"));
+		});
+		expect(result.current.height).toBe(500);
+	});
+
+	test("removes event listeners on unmount", () => {
+		const addResize = vi.spyOn(window, "addEventListener");
+		const removeResize = vi.spyOn(window, "removeEventListener");
+
+		const { unmount } = renderHook(() => useViewportHeight());
+		unmount();
+
+		expect(removeResize).toHaveBeenCalledWith("resize", expect.any(Function));
+		addResize.mockRestore();
+		removeResize.mockRestore();
+	});
 });

package/tests/hooks/useViewportMatch.test.ts

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

package/tests/utils/browserStorage.test.ts

@@ -1,11 +1,11 @@
-import { describe, test, expect, vi, beforeEach, afterEach } from "vitest";
+import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
 import {
 	getLocalStorage,
-	updateLocalStorage,
-	removeLocalStorage,
 	getSessionStorage,
-	updateSessionStorage,
+	removeLocalStorage,
 	removeSessionStorage,
+	updateLocalStorage,
+	updateSessionStorage,
 } from "@/packages/utils/browserStorage";
 
 describe("browserStorage", () => {
@@ -18,16 +18,24 @@ describe("browserStorage", () => {
 
 		const createMockStorage = (store: Record<string, string>) => ({
 			getItem: vi.fn((key) => store[key] ?? null),
-			setItem: vi.fn((key, value) => { store[key] = value.toString(); }),
-			removeItem: vi.fn((key) => { delete store[key]; }),
-			clear: vi.fn(() => { Object.keys(store).forEach((k) => delete store[k]); }),
+			setItem: vi.fn((key, value) => {
+				store[key] = value.toString();
+			}),
+			removeItem: vi.fn((key) => {
+				delete store[key];
+			}),
+			clear: vi.fn(() => {
+				Object.keys(store).forEach((k) => delete store[k]);
+			}),
 		});
 
 		vi.stubGlobal("localStorage", createMockStorage(mockStorage));
 		vi.stubGlobal("sessionStorage", createMockStorage(mockStorage2));
 	});
 
-	afterEach(() => { vi.unstubAllGlobals(); });
+	afterEach(() => {
+		vi.unstubAllGlobals();
+	});
 
 	test("localStorage operations", () => {
 		updateLocalStorage("foo", { bar: "baz" });
@@ -51,4 +59,56 @@ describe("browserStorage", () => {
 		localStorage.setItem("invalid", "not-json");
 		expect(getLocalStorage("invalid")).toBeNull();
 	});
+
+	test("returns null when window is undefined (SSR)", () => {
+		const win = global.window;
+		// @ts-expect-error
+		delete global.window;
+		expect(getLocalStorage("foo")).toBeNull();
+		expect(getSessionStorage("foo")).toBeNull();
+		updateLocalStorage("foo", "bar");
+		global.window = win;
+	});
+
+	test("handles storage setItem throwing", () => {
+		const storage = localStorage;
+		vi.spyOn(storage, "setItem").mockImplementation(() => {
+			throw new Error("QuotaExceededError");
+		});
+		updateLocalStorage("foo", "bar");
+		expect(storage.setItem).toHaveBeenCalled();
+	});
+
+	test("removeStorage handles missing storage gracefully", () => {
+		const win = global.window;
+		// @ts-expect-error
+		delete global.window;
+		removeLocalStorage("foo");
+		removeSessionStorage("foo");
+		global.window = win;
+	});
+
+	test("getLocalStorage returns null when getItem throws", () => {
+		const storage = localStorage;
+		vi.spyOn(storage, "getItem").mockImplementation(() => {
+			throw new Error("StorageError");
+		});
+		expect(getLocalStorage("foo")).toBeNull();
+	});
+
+	test("removeLocalStorage handles removeItem throwing", () => {
+		const storage = localStorage;
+		vi.spyOn(storage, "removeItem").mockImplementation(() => {
+			throw new Error("StorageError");
+		});
+		expect(() => removeLocalStorage("foo")).not.toThrow();
+	});
+
+	test("getLocalStorage returns null for non-existent key", () => {
+		expect(getLocalStorage("non-existent-key")).toBeNull();
+	});
+
+	test("sessionStorage returns null for non-existent key", () => {
+		expect(getSessionStorage("non-existent-key")).toBeNull();
+	});
 });

package/tests/utils/buildContext.test.tsx

@@ -1,6 +1,5 @@
-import { describe, test, expect } from "vitest";
 import { render, screen } from "@testing-library/react";
-import React from "react";
+import { describe, expect, test } from "vitest";
 import { buildContext } from "@/packages/utils/buildContext";
 
 describe("buildContext", () => {

package/tests/utils/checkDevice.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect, afterEach } from "vitest";
+import { afterEach, describe, expect, test } from "vitest";
 import { getDeviceInfo } from "@/packages/utils/checkDevice";
 
 describe("getDeviceInfo", () => {
@@ -23,7 +23,8 @@ describe("getDeviceInfo", () => {
 
 	test("detects mobile Chrome", () => {
 		Object.defineProperty(navigator, "userAgent", {
-			value: "Mozilla/5.0 (Linux; Android 13) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Mobile Safari/537.36",
+			value:
+				"Mozilla/5.0 (Linux; Android 13) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Mobile Safari/537.36",
 			writable: true,
 			configurable: true,
 		});
@@ -35,7 +36,8 @@ describe("getDeviceInfo", () => {
 
 	test("detects iOS Safari", () => {
 		Object.defineProperty(navigator, "userAgent", {
-			value: "Mozilla/5.0 (iPhone; CPU iPhone OS 17_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Mobile/15E148 Safari/604.1",
+			value:
+				"Mozilla/5.0 (iPhone; CPU iPhone OS 17_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Mobile/15E148 Safari/604.1",
 			writable: true,
 			configurable: true,
 		});
@@ -49,7 +51,8 @@ describe("getDeviceInfo", () => {
 
 	test("detects desktop Chrome", () => {
 		Object.defineProperty(navigator, "userAgent", {
-			value: "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+			value:
+				"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
 			writable: true,
 			configurable: true,
 		});
@@ -60,7 +63,8 @@ describe("getDeviceInfo", () => {
 
 	test("detects Mac Safari", () => {
 		Object.defineProperty(navigator, "userAgent", {
-			value: "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Safari/604.1",
+			value:
+				"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Safari/604.1",
 			writable: true,
 			configurable: true,
 		});
@@ -71,9 +75,41 @@ describe("getDeviceInfo", () => {
 		expect(info.browser).toBe("safari");
 	});
 
+	test("detects Firefox browser", () => {
+		Object.defineProperty(navigator, "userAgent", {
+			value: "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:120.0) Gecko/20100101 Firefox/120.0",
+			writable: true,
+			configurable: true,
+		});
+		const info = getDeviceInfo();
+		expect(info.browser).toBe("firefox");
+	});
+
+	test("detects Edge browser", () => {
+		Object.defineProperty(navigator, "userAgent", {
+			value:
+				"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Edge/44.18362.1.0",
+			writable: true,
+			configurable: true,
+		});
+		const info = getDeviceInfo();
+		expect(info.browser).toBe("edge");
+	});
+
+	test("returns unknown browser for unrecognized UA", () => {
+		Object.defineProperty(navigator, "userAgent", {
+			value: "SomeUnknownBrowser/1.0",
+			writable: true,
+			configurable: true,
+		});
+		const info = getDeviceInfo();
+		expect(info.browser).toBe("unknown");
+	});
+
 	test("detects Samsung Browser", () => {
 		Object.defineProperty(navigator, "userAgent", {
-			value: "Mozilla/5.0 (Linux; Android 14) AppleWebKit/537.36 (KHTML, like Gecko) SamsungBrowser/24.0 Chrome/120.0.6099.230 Mobile Safari/537.36",
+			value:
+				"Mozilla/5.0 (Linux; Android 14) AppleWebKit/537.36 (KHTML, like Gecko) SamsungBrowser/24.0 Chrome/120.0.6099.230 Mobile Safari/537.36",
 			writable: true,
 			configurable: true,
 		});
@@ -81,4 +117,24 @@ describe("getDeviceInfo", () => {
 		expect(info.isSamsungBrowser).toBe(true);
 		expect(info.browser).toBe("samsung");
 	});
+
+	test("detects isTouchDevice correctly", () => {
+		const hasTouch = "ontouchstart" in window;
+		const info = getDeviceInfo();
+		expect(info.isTouchDevice).toBe(hasTouch);
+	});
+
+	test("detects desktop Safari correctly distinguishes from mobile", () => {
+		Object.defineProperty(navigator, "userAgent", {
+			value:
+				"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Safari/604.1",
+			writable: true,
+			configurable: true,
+		});
+		const info = getDeviceInfo();
+		expect(info.isSafari).toBe(true);
+		expect(info.isMacSafari).toBe(true);
+		expect(info.isIOSSafari).toBe(false);
+		expect(info.isMobile).toBe(false);
+	});
 });

package/tests/utils/clipboardShare.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect, vi, afterEach } from "vitest";
+import { afterEach, describe, expect, test, vi } from "vitest";
 import { NavigatorClipboard, NavigatorShare } from "@/packages/utils/clipboardShare";
 
 describe("NavigatorClipboard", () => {
@@ -26,7 +26,9 @@ describe("NavigatorClipboard", () => {
 });
 
 describe("NavigatorShare", () => {
-	afterEach(() => { vi.restoreAllMocks(); });
+	afterEach(() => {
+		vi.restoreAllMocks();
+	});
 
 	test("uses Web Share API when available", async () => {
 		Object.defineProperty(navigator, "share", {
@@ -40,7 +42,11 @@ describe("NavigatorShare", () => {
 			configurable: true,
 		});
 
-		const result = await NavigatorShare({ title: "Test", text: "Hello", link: "https://example.com" });
+		const result = await NavigatorShare({
+			title: "Test",
+			text: "Hello",
+			link: "https://example.com",
+		});
 		expect(result).toEqual({ success: true, method: "share" });
 	});
 
@@ -56,10 +62,74 @@ describe("NavigatorShare", () => {
 			configurable: true,
 		});
 
-		const result = await NavigatorShare({ title: "Test", text: "Hello", link: "https://example.com" });
+		const result = await NavigatorShare({
+			title: "Test",
+			text: "Hello",
+			link: "https://example.com",
+		});
+		expect(result).toEqual({ success: true, method: "clipboard" });
+	});
+
+	test("handles AbortError from Web Share API", async () => {
+		Object.defineProperty(navigator, "share", {
+			value: vi.fn(() => Promise.reject(new DOMException("Aborted", "AbortError"))),
+			writable: true,
+			configurable: true,
+		});
+		Object.defineProperty(navigator, "clipboard", {
+			value: { writeText: vi.fn() },
+			writable: true,
+			configurable: true,
+		});
+
+		const result = await NavigatorShare({
+			title: "Test",
+			text: "Hello",
+			link: "https://example.com",
+		});
+		expect(result).toEqual({ success: false, method: "share" });
+	});
+
+	test("falls back to clipboard on non-AbortError share rejection", async () => {
+		Object.defineProperty(navigator, "share", {
+			value: vi.fn(() => Promise.reject(new Error("NotAllowedError"))),
+			writable: true,
+			configurable: true,
+		});
+		Object.defineProperty(navigator, "clipboard", {
+			value: { writeText: vi.fn(() => Promise.resolve()) },
+			writable: true,
+			configurable: true,
+		});
+
+		const result = await NavigatorShare({
+			title: "Test",
+			text: "Hello",
+			link: "https://example.com",
+		});
 		expect(result).toEqual({ success: true, method: "clipboard" });
 	});
 
+	test("clipboard fallback rejects with unsupported", async () => {
+		Object.defineProperty(navigator, "share", {
+			value: vi.fn(() => Promise.reject(new Error("share failed"))),
+			writable: true,
+			configurable: true,
+		});
+		Object.defineProperty(navigator, "clipboard", {
+			value: { writeText: vi.fn(() => Promise.reject(new Error("clipboard denied"))) },
+			writable: true,
+			configurable: true,
+		});
+
+		const result = await NavigatorShare({
+			title: "Test",
+			text: "Hello",
+			link: "https://example.com",
+		});
+		expect(result).toEqual({ success: false, method: "unsupported" });
+	});
+
 	test("returns unsupported when neither share nor clipboard", async () => {
 		Object.defineProperty(navigator, "share", {
 			value: undefined,
@@ -72,7 +142,11 @@ describe("NavigatorShare", () => {
 			configurable: true,
 		});
 
-		const result = await NavigatorShare({ title: "Test", text: "Hello", link: "https://example.com" });
+		const result = await NavigatorShare({
+			title: "Test",
+			text: "Hello",
+			link: "https://example.com",
+		});
 		expect(result).toEqual({ success: false, method: "unsupported" });
 	});
 });