@musecat/functionkit 1.1.0 → 1.2.0

package/tests/hooks/useDebouncedCallback.test.ts

@@ -1,63 +0,0 @@
-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();
-	});
-
-	test("debounces onChange calls", () => {
-		const onChange = vi.fn();
-		const { result } = renderHook(() => useDebouncedCallback({ onChange, timeThreshold: 100 }));
-
-		act(() => {
-			result.current(true);
-		});
-		vi.advanceTimersByTime(100);
-		expect(onChange).toHaveBeenCalledWith(true);
-	});
-
-	test("works with leading: true", () => {
-		const onChange = vi.fn();
-		const { result } = renderHook(() =>
-			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);
-		});
-		vi.advanceTimersByTime(100);
-		expect(onChange).toHaveBeenCalledTimes(1);
-
-		act(() => {
-			result.current(true);
-		});
-		vi.advanceTimersByTime(100);
-		expect(onChange).toHaveBeenCalledTimes(1);
-	});
-});

package/tests/hooks/useDoubleClick.test.ts

@@ -1,82 +0,0 @@
-import { act, renderHook } from "@testing-library/react";
-import { afterEach, describe, expect, test, vi } from "vitest";
-import { useDoubleClick } from "@/packages/hooks/useDoubleClick";
-
-describe("useDoubleClick", () => {
-	afterEach(() => {
-		vi.useRealTimers();
-	});
-
-	test("fires click on single click (event.detail === 1)", () => {
-		vi.useFakeTimers();
-		const click = vi.fn();
-		const doubleClick = vi.fn();
-		const { result } = renderHook(() => useDoubleClick({ click, doubleClick }));
-
-		const event = new MouseEvent("click", {
-			detail: 1,
-		}) as unknown as React.MouseEvent<HTMLElement>;
-		act(() => {
-			result.current(event);
-		});
-		expect(doubleClick).not.toHaveBeenCalled();
-		vi.advanceTimersByTime(300);
-		expect(click).toHaveBeenCalledOnce();
-	});
-
-	test("clears pending timeout on unmount", () => {
-		vi.useFakeTimers();
-		const clearTimeoutSpy = vi.spyOn(window, "clearTimeout");
-		const click = vi.fn();
-		const doubleClick = vi.fn();
-		const { result, unmount } = renderHook(() => useDoubleClick({ click, doubleClick }));
-
-		const event = new MouseEvent("click", {
-			detail: 1,
-		}) as unknown as React.MouseEvent<HTMLElement>;
-		act(() => {
-			result.current(event);
-		});
-		unmount();
-		expect(clearTimeoutSpy).toHaveBeenCalled();
-		clearTimeoutSpy.mockRestore();
-	});
-
-	test("handles second click before first timeout (race condition)", () => {
-		vi.useFakeTimers();
-		const click = vi.fn();
-		const doubleClick = vi.fn();
-		const { result } = renderHook(() => useDoubleClick({ click, doubleClick }));
-
-		const event1 = new MouseEvent("click", {
-			detail: 1,
-		}) as unknown as React.MouseEvent<HTMLElement>;
-		const event2 = new MouseEvent("click", {
-			detail: 1,
-		}) as unknown as React.MouseEvent<HTMLElement>;
-
-		act(() => {
-			result.current(event1);
-		});
-		act(() => {
-			result.current(event2);
-		});
-		vi.advanceTimersByTime(300);
-		expect(click).toHaveBeenCalledTimes(1);
-	});
-
-	test("fires doubleClick on double click (event.detail === 2)", () => {
-		const click = vi.fn();
-		const doubleClick = vi.fn();
-		const { result } = renderHook(() => useDoubleClick({ click, doubleClick }));
-
-		const event = new MouseEvent("click", {
-			detail: 2,
-		}) as unknown as React.MouseEvent<HTMLElement>;
-		act(() => {
-			result.current(event);
-		});
-		expect(doubleClick).toHaveBeenCalledOnce();
-		expect(click).not.toHaveBeenCalled();
-	});
-});

package/tests/hooks/useGeolocation.test.ts

@@ -1,201 +0,0 @@
-import { act, renderHook } from "@testing-library/react";
-import { beforeEach, describe, expect, type Mock, test, vi } from "vitest";
-import { useGeolocation } from "@/packages/hooks/useGeolocation";
-
-describe("useGeolocation", () => {
-	let mockGeolocation: {
-		getCurrentPosition: Mock;
-		watchPosition: Mock;
-		clearWatch: Mock;
-	};
-
-	beforeEach(() => {
-		mockGeolocation = {
-			getCurrentPosition: vi.fn((success) =>
-				success({
-					coords: {
-						latitude: 37.5665,
-						longitude: 126.978,
-						accuracy: 10,
-						altitude: null,
-						altitudeAccuracy: null,
-						heading: null,
-						speed: null,
-					},
-					timestamp: Date.now(),
-				}),
-			),
-			watchPosition: vi.fn(),
-			clearWatch: vi.fn(),
-		};
-		Object.defineProperty(navigator, "geolocation", {
-			value: mockGeolocation,
-			writable: true,
-			configurable: true,
-		});
-	});
-
-	test("returns default state", () => {
-		const { result } = renderHook(() => useGeolocation());
-		expect(result.current.loading).toBe(false);
-		expect(result.current.error).toBeNull();
-		expect(result.current.data).toBeNull();
-	});
-
-	test("getCurrentPosition fetches location and updates state", () => {
-		const { result } = renderHook(() => useGeolocation());
-		act(() => {
-			result.current.getCurrentPosition();
-		});
-		expect(mockGeolocation.getCurrentPosition).toHaveBeenCalledOnce();
-		expect(result.current.loading).toBe(false);
-		expect(result.current.data?.latitude).toBe(37.5665);
-	});
-
-	test("getCurrentPosition with mount behavior GET", () => {
-		renderHook(() => useGeolocation({ mountBehavior: "get" }));
-		expect(mockGeolocation.getCurrentPosition).toHaveBeenCalled();
-	});
-
-	test("mount behavior GET calls getCurrentPosition with geoOptions", () => {
-		renderHook(() => useGeolocation({ mountBehavior: "get", enableHighAccuracy: true }));
-		expect(mockGeolocation.getCurrentPosition).toHaveBeenCalledWith(
-			expect.any(Function),
-			expect.any(Function),
-			expect.objectContaining({ enableHighAccuracy: true }),
-		);
-	});
-
-	test("clears existing watch before starting new tracking", () => {
-		mockGeolocation.watchPosition = vi.fn(() => 789);
-		const { result } = renderHook(() => useGeolocation());
-		act(() => {
-			result.current.startTracking();
-		});
-		act(() => {
-			result.current.startTracking();
-		});
-		expect(mockGeolocation.clearWatch).toHaveBeenCalledWith(789);
-	});
-
-	test("startTracking returns early when geolocation unsupported", () => {
-		const origGeolocation = navigator.geolocation;
-		Object.defineProperty(navigator, "geolocation", {
-			value: undefined,
-			writable: true,
-			configurable: true,
-		});
-		const { result } = renderHook(() => useGeolocation());
-		act(() => {
-			result.current.startTracking();
-		});
-		expect(result.current.error).toBe("Geolocation is not supported by this environment.");
-		Object.defineProperty(navigator, "geolocation", {
-			value: origGeolocation,
-			writable: true,
-			configurable: true,
-		});
-	});
-
-	test("startTracking calls watchPosition", () => {
-		const watchSuccess = vi.fn();
-		mockGeolocation.watchPosition = vi.fn((success) => {
-			watchSuccess.mockImplementation(() =>
-				success({
-					coords: {
-						latitude: 37.5,
-						longitude: 127.0,
-						accuracy: 5,
-						altitude: null,
-						altitudeAccuracy: null,
-						heading: null,
-						speed: null,
-					},
-					timestamp: Date.now(),
-				}),
-			);
-		});
-		const { result } = renderHook(() => useGeolocation());
-		act(() => {
-			result.current.startTracking();
-		});
-		expect(mockGeolocation.watchPosition).toHaveBeenCalled();
-	});
-
-	test("startTracking with mount behavior WATCH", () => {
-		mockGeolocation.watchPosition = vi.fn((success) =>
-			success({
-				coords: {
-					latitude: 37.5,
-					longitude: 127.0,
-					accuracy: 5,
-					altitude: null,
-					altitudeAccuracy: null,
-					heading: null,
-					speed: null,
-				},
-				timestamp: Date.now(),
-			}),
-		);
-		renderHook(() => useGeolocation({ mountBehavior: "watch" }));
-		expect(mockGeolocation.watchPosition).toHaveBeenCalled();
-	});
-
-	test("stopTracking clears watch and sets isTracking to false", () => {
-		mockGeolocation.watchPosition = vi.fn(() => 123);
-		const { result } = renderHook(() => useGeolocation());
-		act(() => {
-			result.current.startTracking();
-		});
-		act(() => {
-			result.current.stopTracking();
-		});
-		expect(mockGeolocation.clearWatch).toHaveBeenCalledWith(123);
-		expect(result.current.isTracking).toBe(false);
-	});
-
-	test("stopTracking does nothing when no watch is active", () => {
-		const { result } = renderHook(() => useGeolocation());
-		act(() => {
-			result.current.stopTracking();
-		});
-		expect(mockGeolocation.clearWatch).not.toHaveBeenCalled();
-	});
-
-	test("clears watch on unmount when tracking", () => {
-		mockGeolocation.watchPosition = vi.fn(() => 456);
-		const { unmount } = renderHook(() => useGeolocation({ mountBehavior: "watch" }));
-		unmount();
-		expect(mockGeolocation.clearWatch).toHaveBeenCalledWith(456);
-	});
-
-	test("handles unsupported geolocation", () => {
-		const origGeolocation = navigator.geolocation;
-		Object.defineProperty(navigator, "geolocation", {
-			value: undefined,
-			writable: true,
-			configurable: true,
-		});
-		const { result } = renderHook(() => useGeolocation());
-		act(() => {
-			result.current.getCurrentPosition();
-		});
-		expect(result.current.error).toBe("Geolocation is not supported by this environment.");
-		Object.defineProperty(navigator, "geolocation", {
-			value: origGeolocation,
-			writable: true,
-			configurable: true,
-		});
-	});
-
-	test("handles geolocation error", () => {
-		mockGeolocation.getCurrentPosition = vi.fn((_success, error) =>
-			error?.({ message: "User denied geolocation" }),
-		);
-		const { result } = renderHook(() => useGeolocation());
-		act(() => {
-			result.current.getCurrentPosition();
-		});
-		expect(result.current.error).toBe("User denied geolocation");
-	});
-});

package/tests/hooks/useHasMounted.test.ts

@@ -1,10 +0,0 @@
-import { renderHook } from "@testing-library/react";
-import { describe, expect, test } from "vitest";
-import { useHasMounted } from "@/packages/hooks/useHasMounted";
-
-describe("useHasMounted", () => {
-	test("returns true after mount", () => {
-		const { result } = renderHook(() => useHasMounted());
-		expect(result.current).toBe(true);
-	});
-});

package/tests/hooks/useIntersectionObserver.test.ts

@@ -1,78 +0,0 @@
-import { act, renderHook } from "@testing-library/react";
-import { describe, expect, test, vi } from "vitest";
-import { useIntersectionObserver } from "@/packages/hooks/useIntersectionObserver";
-
-describe("useIntersectionObserver", () => {
-	beforeEach(() => {
-		const mockObserve = vi.fn();
-		const mockUnobserve = vi.fn();
-		class MockIntersectionObserver {
-			observe = mockObserve;
-			unobserve = mockUnobserve;
-			constructor(
-				public callback: IntersectionObserverCallback,
-				public options?: IntersectionObserverInit,
-			) {}
-		}
-		vi.stubGlobal("IntersectionObserver", MockIntersectionObserver);
-	});
-
-	test("returns a ref callback", () => {
-		const callback = vi.fn();
-		const { result } = renderHook(() => useIntersectionObserver(callback, { threshold: 0 }));
-		expect(typeof result.current).toBe("function");
-	});
-
-	test("observes element when ref is attached", () => {
-		const callback = vi.fn();
-		const { result } = renderHook(() => useIntersectionObserver(callback, { threshold: 0 }));
-
-		const element = document.createElement("div");
-		act(() => {
-			(result.current as (el: HTMLElement | null) => void)(element);
-		});
-		expect(callback).not.toHaveBeenCalled();
-	});
-
-	test("triggers observer callback when intersection fires", () => {
-		let observerCallback: IntersectionObserverCallback = () => {};
-		class MockIO {
-			constructor(cb: IntersectionObserverCallback) {
-				observerCallback = cb;
-			}
-			observe = vi.fn();
-			unobserve = vi.fn();
-		}
-		vi.stubGlobal("IntersectionObserver", MockIO);
-
-		const callback = vi.fn();
-		renderHook(() => useIntersectionObserver(callback, { threshold: 0 }));
-
-		const entry = { isIntersecting: true } as IntersectionObserverEntry;
-		observerCallback([entry], {} as IntersectionObserver);
-		expect(callback).toHaveBeenCalledWith(entry);
-	});
-
-	test("unobserves element when ref is detached", () => {
-		const callback = vi.fn();
-		const { result } = renderHook(() => useIntersectionObserver(callback, { threshold: 0 }));
-
-		const element = document.createElement("div");
-		act(() => {
-			(result.current as (el: HTMLElement | null) => void)(element);
-		});
-		act(() => {
-			(result.current as (el: HTMLElement | null) => void)(null);
-		});
-	});
-
-	test("returns noop when IntersectionObserver is undefined", () => {
-		const origIO = global.IntersectionObserver;
-		// @ts-expect-error
-		delete global.IntersectionObserver;
-		const callback = vi.fn();
-		const { result } = renderHook(() => useIntersectionObserver(callback, { threshold: 0 }));
-		expect(typeof result.current).toBe("function");
-		global.IntersectionObserver = origIO;
-	});
-});

package/tests/hooks/useInterval.test.ts

@@ -1,56 +0,0 @@
-import { renderHook } from "@testing-library/react";
-import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
-import { useInterval } from "@/packages/hooks/useInterval";
-
-describe("useInterval", () => {
-	beforeEach(() => {
-		vi.useFakeTimers();
-	});
-	afterEach(() => {
-		vi.useRealTimers();
-	});
-
-	test("calls callback repeatedly at interval", () => {
-		const fn = vi.fn();
-		renderHook(() => useInterval(fn, 100));
-		expect(fn).not.toHaveBeenCalled();
-		vi.advanceTimersByTime(100);
-		expect(fn).toHaveBeenCalledTimes(1);
-		vi.advanceTimersByTime(100);
-		expect(fn).toHaveBeenCalledTimes(2);
-	});
-
-	test("calls immediately with immediate option", () => {
-		const fn = vi.fn();
-		renderHook(() => useInterval(fn, { delay: 100, immediate: true }));
-		expect(fn).toHaveBeenCalledOnce();
-	});
-
-	test("does not call immediate when enabled is false", () => {
-		const fn = vi.fn();
-		renderHook(() => useInterval(fn, { delay: 100, immediate: true, enabled: false }));
-		expect(fn).not.toHaveBeenCalled();
-	});
-
-	test("handles immediate StrictMode double-fire guard", () => {
-		const fn = vi.fn();
-		const { rerender } = renderHook(
-			({ immediate, enabled }: { immediate?: boolean; enabled?: boolean }) =>
-				useInterval(fn, { delay: 100, immediate, enabled }),
-			{ initialProps: { immediate: true, enabled: true } },
-		);
-		expect(fn).toHaveBeenCalledTimes(1);
-		// Toggle enabled to trigger effect re-run while immediateCalledRef is still true
-		rerender({ immediate: true, enabled: false });
-		rerender({ immediate: true, enabled: true });
-		// Should not call callback again (ref already set)
-		expect(fn).toHaveBeenCalledTimes(1);
-	});
-
-	test("does not call when disabled", () => {
-		const fn = vi.fn();
-		renderHook(() => useInterval(fn, { delay: 100, enabled: false }));
-		vi.advanceTimersByTime(200);
-		expect(fn).not.toHaveBeenCalled();
-	});
-});

package/tests/hooks/useKeyboardHeight.test.ts

@@ -1,10 +0,0 @@
-import { renderHook } from "@testing-library/react";
-import { describe, expect, test } from "vitest";
-import { useKeyboardHeight } from "@/packages/hooks/useKeyboardHeight";
-
-describe("useKeyboardHeight", () => {
-	test("returns default keyboard height of 0", () => {
-		const { result } = renderHook(() => useKeyboardHeight());
-		expect(result.current.keyboardHeight).toBe(0);
-	});
-});