@musecat/functionkit 1.0.1 → 1.0.2

package/tests/hooks/useLongPress.test.ts

@@ -0,0 +1,52 @@
+import { describe, test, expect, vi, beforeEach, afterEach } from "vitest";
+import { renderHook, act } from "@testing-library/react";
+import type React from "react";
+import { useLongPress } from "@/packages/hooks/useLongPress";
+
+function createMouseEvent(type: string): React.MouseEvent<HTMLElement> {
+	return {
+		type,
+		nativeEvent: new MouseEvent(type, { clientX: 0, clientY: 0 }),
+		clientX: 0,
+		clientY: 0,
+	} as unknown as React.MouseEvent<HTMLElement>;
+}
+
+describe("useLongPress", () => {
+	beforeEach(() => { vi.useFakeTimers(); });
+	afterEach(() => { vi.useRealTimers(); });
+
+	test("fires onLongPress after delay", () => {
+		const onLongPress = vi.fn();
+		const { result } = renderHook(() => useLongPress(onLongPress, { delay: 200 }));
+
+		act(() => { result.current.onMouseDown(createMouseEvent("mousedown")); });
+		expect(onLongPress).not.toHaveBeenCalled();
+		vi.advanceTimersByTime(200);
+		expect(onLongPress).toHaveBeenCalledOnce();
+	});
+
+	test("fires onClick when released before delay", () => {
+		const onLongPress = vi.fn();
+		const onClick = vi.fn();
+		const { result } = renderHook(() =>
+			useLongPress(onLongPress, { delay: 200, onClick }),
+		);
+
+		act(() => { result.current.onMouseDown(createMouseEvent("mousedown")); });
+		act(() => { result.current.onMouseUp(createMouseEvent("mouseup")); });
+		vi.advanceTimersByTime(200);
+		expect(onLongPress).not.toHaveBeenCalled();
+		expect(onClick).toHaveBeenCalledOnce();
+	});
+
+	test("cancels on mouse leave", () => {
+		const onLongPress = vi.fn();
+		const { result } = renderHook(() => useLongPress(onLongPress, { delay: 200 }));
+
+		act(() => { result.current.onMouseDown(createMouseEvent("mousedown")); });
+		act(() => { result.current.onMouseLeave(createMouseEvent("mouseleave")); });
+		vi.advanceTimersByTime(200);
+		expect(onLongPress).not.toHaveBeenCalled();
+	});
+});

package/tests/hooks/usePreservedCallback.test.ts

@@ -0,0 +1,35 @@
+import { describe, test, expect, vi } from "vitest";
+import { renderHook } from "@testing-library/react";
+import { usePreservedCallback } from "@/packages/hooks/usePreservedCallback";
+
+describe("usePreservedCallback", () => {
+	test("returns a stable function reference across renders", () => {
+		const { result, rerender } = renderHook(
+			({ cb }) => usePreservedCallback(cb),
+			{ initialProps: { cb: vi.fn() } },
+		);
+		const firstRef = result.current;
+		rerender({ cb: vi.fn() });
+		expect(result.current).toBe(firstRef);
+	});
+
+	test("invokes the latest callback", () => {
+		const fn1 = vi.fn();
+		const fn2 = vi.fn();
+		const { result, rerender } = renderHook(
+			({ cb }) => usePreservedCallback(cb),
+			{ initialProps: { cb: fn1 } },
+		);
+		rerender({ cb: fn2 });
+		result.current();
+		expect(fn2).toHaveBeenCalledOnce();
+		expect(fn1).not.toHaveBeenCalled();
+	});
+
+	test("passes arguments through", () => {
+		const fn = vi.fn();
+		const { result } = renderHook(() => usePreservedCallback(fn));
+		result.current("a", 1);
+		expect(fn).toHaveBeenCalledWith("a", 1);
+	});
+});

package/tests/hooks/usePreservedReference.test.ts

@@ -0,0 +1,35 @@
+import { describe, test, expect, vi } from "vitest";
+import { renderHook } from "@testing-library/react";
+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 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 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);
+	});
+});

package/tests/hooks/useRefEffect.test.ts

@@ -0,0 +1,30 @@
+import { describe, test, expect, vi } from "vitest";
+import { renderHook, act } from "@testing-library/react";
+import { useRefEffect } from "@/packages/hooks/useRefEffect";
+
+describe("useRefEffect", () => {
+	test("calls callback with element and cleanup on unmount", () => {
+		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); });
+		expect(callback).toHaveBeenCalledWith(element);
+
+		act(() => { (result.current as (el: HTMLElement | null) => void)(null); });
+		expect(cleanup).toHaveBeenCalledOnce();
+	});
+
+	test("calls cleanup before setting new element", () => {
+		const cleanup = vi.fn();
+		const callback = vi.fn(() => cleanup);
+		const { result } = renderHook(() => useRefEffect(callback, []));
+
+		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); });
+		expect(cleanup).toHaveBeenCalledOnce();
+	});
+});

package/tests/hooks/useRelativeDateTime.test.ts

@@ -0,0 +1,19 @@
+import { describe, test, expect, vi, beforeEach, afterEach } from "vitest";
+import { renderHook } from "@testing-library/react";
+import { useRelativeDateTime } from "@/packages/hooks/useRelativeDateTime";
+
+describe("useRelativeDateTime", () => {
+	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" }),
+		);
+		expect(result.current.ready).toBe(true);
+		expect(result.current.isRelative).toBe(true);
+		expect(result.current.text).toBeTruthy();
+	});
+});

package/tests/hooks/useTimeout.test.ts

@@ -0,0 +1,34 @@
+import { describe, test, expect, vi, beforeEach, afterEach } from "vitest";
+import { renderHook, act } from "@testing-library/react";
+import { useTimeout } from "@/packages/hooks/useTimeout";
+
+describe("useTimeout", () => {
+	beforeEach(() => { vi.useFakeTimers(); });
+	afterEach(() => { vi.useRealTimers(); });
+
+	test("calls callback after delay", () => {
+		const fn = vi.fn();
+		renderHook(() => useTimeout(fn, 100));
+		expect(fn).not.toHaveBeenCalled();
+		vi.advanceTimersByTime(100);
+		expect(fn).toHaveBeenCalledOnce();
+	});
+
+	test("does not call when disabled", () => {
+		const fn = vi.fn();
+		renderHook(() => useTimeout(fn, 100, { enabled: false }));
+		vi.advanceTimersByTime(200);
+		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); });
+		expect(result.current.isPending()).toBe(true);
+		vi.advanceTimersByTime(50);
+		expect(fn).toHaveBeenCalledOnce();
+		expect(result.current.isPending()).toBe(false);
+	});
+});

package/tests/hooks/useToggleState.test.ts

@@ -0,0 +1,35 @@
+import { describe, test, expect } from "vitest";
+import { renderHook, act } from "@testing-library/react";
+import { useToggleState } from "@/packages/hooks/useToggleState";
+
+describe("useToggleState", () => {
+	test("initializes with false by default", () => {
+		const { result } = renderHook(() => useToggleState());
+		expect(result.current.value).toBe(false);
+	});
+
+	test("initializes with provided value", () => {
+		const { result } = renderHook(() => useToggleState(true));
+		expect(result.current.value).toBe(true);
+	});
+
+	test("setTrue sets value to true", () => {
+		const { result } = renderHook(() => useToggleState(false));
+		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(); });
+		expect(result.current.value).toBe(false);
+	});
+
+	test("toggle switches value", () => {
+		const { result } = renderHook(() => useToggleState(false));
+		act(() => { result.current.toggle(); });
+		expect(result.current.value).toBe(true);
+		act(() => { result.current.toggle(); });
+		expect(result.current.value).toBe(false);
+	});
+});

package/tests/hooks/useViewportHeight.test.ts

@@ -0,0 +1,10 @@
+import { describe, test, expect } from "vitest";
+import { renderHook } from "@testing-library/react";
+import { useViewportHeight } from "@/packages/hooks/useViewportHeight";
+
+describe("useViewportHeight", () => {
+	test("returns a height value", () => {
+		const { result } = renderHook(() => useViewportHeight());
+		expect(result.current.height).toBeGreaterThanOrEqual(0);
+	});
+});

package/tests/hooks/useViewportMatch.test.ts

@@ -0,0 +1,35 @@
+import { describe, test, expect, vi, beforeEach } from "vitest";
+import { renderHook } from "@testing-library/react";
+import { useViewportMatch } from "@/packages/hooks/useViewportMatch";
+
+describe("useViewportMatch", () => {
+	beforeEach(() => {
+		vi.stubGlobal(
+			"matchMedia",
+			vi.fn().mockImplementation((query: string) => ({
+				matches: false,
+				media: query,
+				addEventListener: vi.fn(),
+				removeEventListener: vi.fn(),
+			})),
+		);
+	});
+
+	test("returns false initially", () => {
+		const { result } = renderHook(() => useViewportMatch("(min-width: 768px)"));
+		expect(result.current).toBe(false);
+	});
+
+	test("returns true when matched", () => {
+		vi.stubGlobal(
+			"matchMedia",
+			vi.fn().mockImplementation(() => ({
+				matches: true,
+				addEventListener: vi.fn(),
+				removeEventListener: vi.fn(),
+			})),
+		);
+		const { result } = renderHook(() => useViewportMatch("(min-width: 768px)"));
+		expect(result.current).toBe(true);
+	});
+});

package/tests/setup.ts

@@ -0,0 +1,9 @@
+import "@testing-library/jest-dom";
+
+class ResizeObserverMock {
+	observe() {}
+	unobserve() {}
+	disconnect() {}
+}
+
+window.ResizeObserver = ResizeObserverMock as unknown as typeof ResizeObserver;

package/tests/utils/browserStorage.test.ts

@@ -0,0 +1,54 @@
+import { describe, test, expect, vi, beforeEach, afterEach } from "vitest";
+import {
+	getLocalStorage,
+	updateLocalStorage,
+	removeLocalStorage,
+	getSessionStorage,
+	updateSessionStorage,
+	removeSessionStorage,
+} from "@/packages/utils/browserStorage";
+
+describe("browserStorage", () => {
+	let mockStorage: Record<string, string>;
+	let mockStorage2: Record<string, string>;
+
+	beforeEach(() => {
+		mockStorage = {};
+		mockStorage2 = {};
+
+		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]); }),
+		});
+
+		vi.stubGlobal("localStorage", createMockStorage(mockStorage));
+		vi.stubGlobal("sessionStorage", createMockStorage(mockStorage2));
+	});
+
+	afterEach(() => { vi.unstubAllGlobals(); });
+
+	test("localStorage operations", () => {
+		updateLocalStorage("foo", { bar: "baz" });
+		expect(localStorage.getItem("foo")).toBe('{"bar":"baz"}');
+		expect(getLocalStorage("foo")).toEqual({ bar: "baz" });
+
+		removeLocalStorage("foo");
+		expect(getLocalStorage("foo")).toBeNull();
+	});
+
+	test("sessionStorage operations", () => {
+		updateSessionStorage("foo", { bar: "baz" });
+		expect(sessionStorage.getItem("foo")).toBe('{"bar":"baz"}');
+		expect(getSessionStorage("foo")).toEqual({ bar: "baz" });
+
+		removeSessionStorage("foo");
+		expect(getSessionStorage("foo")).toBeNull();
+	});
+
+	test("handles invalid json gracefully", () => {
+		localStorage.setItem("invalid", "not-json");
+		expect(getLocalStorage("invalid")).toBeNull();
+	});
+});

package/tests/utils/buildContext.test.tsx

@@ -0,0 +1,27 @@
+import { describe, test, expect } from "vitest";
+import { render, screen } from "@testing-library/react";
+import React from "react";
+import { buildContext } from "@/packages/utils/buildContext";
+
+describe("buildContext", () => {
+	const [Provider, useValue] = buildContext<string>("default");
+
+	function TestComponent() {
+		const val = useValue();
+		return <div data-testid="val">{val}</div>;
+	}
+
+	test("returns default value when not wrapped in provider", () => {
+		render(<TestComponent />);
+		expect(screen.getByTestId("val").textContent).toBe("default");
+	});
+
+	test("returns provided value", () => {
+		render(
+			<Provider value="provided">
+				<TestComponent />
+			</Provider>,
+		);
+		expect(screen.getByTestId("val").textContent).toBe("provided");
+	});
+});

package/tests/utils/checkDevice.test.ts

@@ -0,0 +1,84 @@
+import { describe, test, expect, afterEach } from "vitest";
+import { getDeviceInfo } from "@/packages/utils/checkDevice";
+
+describe("getDeviceInfo", () => {
+	const originalUserAgent = navigator.userAgent;
+
+	afterEach(() => {
+		Object.defineProperty(navigator, "userAgent", {
+			value: originalUserAgent,
+			writable: true,
+			configurable: true,
+		});
+	});
+
+	test("returns default values in SSR (no window)", () => {
+		const win = global.window;
+		(global as any).window = undefined;
+		const info = getDeviceInfo();
+		expect(info.isMobile).toBe(false);
+		expect(info.browser).toBe("unknown");
+		global.window = win;
+	});
+
+	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",
+			writable: true,
+			configurable: true,
+		});
+		const info = getDeviceInfo();
+		expect(info.isMobile).toBe(true);
+		expect(info.isAndroid).toBe(true);
+		expect(info.browser).toBe("chrome");
+	});
+
+	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",
+			writable: true,
+			configurable: true,
+		});
+		const info = getDeviceInfo();
+		expect(info.isMobile).toBe(true);
+		expect(info.isIOS).toBe(true);
+		expect(info.isSafari).toBe(true);
+		expect(info.isIOSSafari).toBe(true);
+		expect(info.browser).toBe("safari");
+	});
+
+	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",
+			writable: true,
+			configurable: true,
+		});
+		const info = getDeviceInfo();
+		expect(info.isMobile).toBe(false);
+		expect(info.browser).toBe("chrome");
+	});
+
+	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",
+			writable: true,
+			configurable: true,
+		});
+		const info = getDeviceInfo();
+		expect(info.isMobile).toBe(false);
+		expect(info.isMacSafari).toBe(true);
+		expect(info.isSafari).toBe(true);
+		expect(info.browser).toBe("safari");
+	});
+
+	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",
+			writable: true,
+			configurable: true,
+		});
+		const info = getDeviceInfo();
+		expect(info.isSamsungBrowser).toBe(true);
+		expect(info.browser).toBe("samsung");
+	});
+});

package/tests/utils/clipboardShare.test.ts

@@ -0,0 +1,78 @@
+import { describe, test, expect, vi, afterEach } from "vitest";
+import { NavigatorClipboard, NavigatorShare } from "@/packages/utils/clipboardShare";
+
+describe("NavigatorClipboard", () => {
+	test("resolves with success: true on write", async () => {
+		Object.defineProperty(navigator, "clipboard", {
+			value: { writeText: vi.fn(() => Promise.resolve()) },
+			writable: true,
+			configurable: true,
+		});
+
+		const result = await NavigatorClipboard({ text: "hello" });
+		expect(result).toEqual({ success: true });
+	});
+
+	test("resolves with success: false on failure", async () => {
+		Object.defineProperty(navigator, "clipboard", {
+			value: { writeText: vi.fn(() => Promise.reject(new Error("denied"))) },
+			writable: true,
+			configurable: true,
+		});
+
+		const result = await NavigatorClipboard({ text: "hello" });
+		expect(result).toEqual({ success: false });
+	});
+});
+
+describe("NavigatorShare", () => {
+	afterEach(() => { vi.restoreAllMocks(); });
+
+	test("uses Web Share API when available", async () => {
+		Object.defineProperty(navigator, "share", {
+			value: vi.fn(() => Promise.resolve()),
+			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: true, method: "share" });
+	});
+
+	test("falls back to clipboard when share is unavailable", async () => {
+		Object.defineProperty(navigator, "share", {
+			value: undefined,
+			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("returns unsupported when neither share nor clipboard", async () => {
+		Object.defineProperty(navigator, "share", {
+			value: undefined,
+			writable: true,
+			configurable: true,
+		});
+		Object.defineProperty(navigator, "clipboard", {
+			value: undefined,
+			writable: true,
+			configurable: true,
+		});
+
+		const result = await NavigatorShare({ title: "Test", text: "Hello", link: "https://example.com" });
+		expect(result).toEqual({ success: false, method: "unsupported" });
+	});
+});

package/tests/utils/floatingMotion.test.ts

@@ -0,0 +1,84 @@
+import { describe, test, expect } from "vitest";
+import {
+	getFloatingMotionPreset,
+	getFloatingTransformOrigin,
+	getFloatingHiddenTransform,
+} from "@/packages/utils/floatingMotion";
+
+describe("getFloatingMotionPreset", () => {
+	test("returns anchored preset", () => {
+		const preset = getFloatingMotionPreset("anchored");
+		expect(preset.enterMs).toBe(230);
+		expect(preset.exitMs).toBe(170);
+	});
+
+	test("returns modal-center preset", () => {
+		const preset = getFloatingMotionPreset("modal-center");
+		expect(preset.enterMs).toBe(340);
+		expect(preset.exitMs).toBe(260);
+	});
+
+	test("returns center-selected preset", () => {
+		const preset = getFloatingMotionPreset("center-selected");
+		expect(preset.enterMs).toBe(190);
+		expect(preset.exitMs).toBe(140);
+	});
+
+	test("returns mobile-sheet preset", () => {
+		const preset = getFloatingMotionPreset("mobile-sheet");
+		expect(preset.enterMs).toBe(360);
+		expect(preset.exitMs).toBe(280);
+	});
+});
+
+describe("getFloatingTransformOrigin", () => {
+	test("returns default when no placement", () => {
+		expect(getFloatingTransformOrigin()).toBe("top center");
+	});
+
+	test("returns correct origin for top-left", () => {
+		expect(getFloatingTransformOrigin("top-left")).toBe("bottom left");
+	});
+
+	test("returns correct origin for bottom-right", () => {
+		expect(getFloatingTransformOrigin("bottom-right")).toBe("top right");
+	});
+
+	test("returns correct origin for middle-center", () => {
+		expect(getFloatingTransformOrigin("middle-center")).toBe("center center");
+	});
+});
+
+describe("getFloatingHiddenTransform", () => {
+	test("returns mobile-sheet transform", () => {
+		expect(getFloatingHiddenTransform({ mode: "mobile-sheet" })).toBe("translateY(1.8rem) scale(1)");
+	});
+
+	test("returns modal-center transform", () => {
+		expect(getFloatingHiddenTransform({ mode: "modal-center" })).toBe("translateY(.8rem) scale(.94)");
+	});
+
+	test("returns center-selected transform", () => {
+		expect(getFloatingHiddenTransform({ mode: "center-selected" })).toBe("translateY(.45rem) scale(.99)");
+	});
+
+	test("anchored with no placement", () => {
+		expect(getFloatingHiddenTransform({ mode: "anchored" })).toBe("translateY(.4rem) scale(.975)");
+	});
+
+	test("anchored with top placement", () => {
+		expect(getFloatingHiddenTransform({ mode: "anchored", placement: "top-left" })).toBe("translateY(.4rem) scale(.975)");
+	});
+
+	test("anchored with bottom placement", () => {
+		expect(getFloatingHiddenTransform({ mode: "anchored", placement: "bottom-center" })).toBe("translateY(-.4rem) scale(.975)");
+	});
+
+	test("anchored with middle-left placement", () => {
+		expect(getFloatingHiddenTransform({ mode: "anchored", placement: "middle-left" })).toBe("translateX(.4rem) scale(.975)");
+	});
+
+	test("anchored with middle-right placement", () => {
+		expect(getFloatingHiddenTransform({ mode: "anchored", placement: "middle-right" })).toBe("translateX(-.4rem) scale(.975)");
+	});
+});

package/tests/utils/keyboardTarget.test.ts

@@ -0,0 +1,44 @@
+import { describe, test, expect } from "vitest";
+import { isEditableKeyboardTarget } from "@/packages/utils/keyboardTarget";
+
+describe("isEditableKeyboardTarget", () => {
+	test("returns true for contentEditable", () => {
+		const el = document.createElement("div");
+		Object.defineProperty(el, "isContentEditable", { value: true });
+		expect(isEditableKeyboardTarget(el)).toBe(true);
+	});
+
+	test("returns true for TEXTAREA", () => {
+		const el = document.createElement("textarea");
+		expect(isEditableKeyboardTarget(el)).toBe(true);
+	});
+
+	test("returns true for text INPUT", () => {
+		const el = document.createElement("input");
+		el.type = "text";
+		expect(isEditableKeyboardTarget(el)).toBe(true);
+	});
+
+	test("returns false for button INPUT", () => {
+		const el = document.createElement("input");
+		el.type = "button";
+		expect(isEditableKeyboardTarget(el)).toBe(false);
+	});
+
+	test("returns false for checkbox INPUT", () => {
+		const el = document.createElement("input");
+		el.type = "checkbox";
+		expect(isEditableKeyboardTarget(el)).toBe(false);
+	});
+
+	test("returns false for radio INPUT", () => {
+		const el = document.createElement("input");
+		el.type = "radio";
+		expect(isEditableKeyboardTarget(el)).toBe(false);
+	});
+
+	test("returns false for regular div", () => {
+		const el = document.createElement("div");
+		expect(isEditableKeyboardTarget(el)).toBe(false);
+	});
+});