@musecat/functionkit 1.0.2 → 1.1.0

package/tests/utils/floatingMotion.test.ts

@@ -1,8 +1,8 @@
-import { describe, test, expect } from "vitest";
+import { describe, expect, test } from "vitest";
 import {
+	getFloatingHiddenTransform,
 	getFloatingMotionPreset,
 	getFloatingTransformOrigin,
-	getFloatingHiddenTransform,
 } from "@/packages/utils/floatingMotion";
 
 describe("getFloatingMotionPreset", () => {
@@ -47,19 +47,49 @@ describe("getFloatingTransformOrigin", () => {
 	test("returns correct origin for middle-center", () => {
 		expect(getFloatingTransformOrigin("middle-center")).toBe("center center");
 	});
+
+	test("returns correct origin for top-center", () => {
+		expect(getFloatingTransformOrigin("top-center")).toBe("bottom center");
+	});
+
+	test("returns correct origin for top-right", () => {
+		expect(getFloatingTransformOrigin("top-right")).toBe("bottom right");
+	});
+
+	test("returns correct origin for middle-left", () => {
+		expect(getFloatingTransformOrigin("middle-left")).toBe("center left");
+	});
+
+	test("returns correct origin for middle-right", () => {
+		expect(getFloatingTransformOrigin("middle-right")).toBe("center right");
+	});
+
+	test("returns correct origin for bottom-left", () => {
+		expect(getFloatingTransformOrigin("bottom-left")).toBe("top left");
+	});
+
+	test("returns correct origin for bottom-center", () => {
+		expect(getFloatingTransformOrigin("bottom-center")).toBe("top center");
+	});
 });
 
 describe("getFloatingHiddenTransform", () => {
 	test("returns mobile-sheet transform", () => {
-		expect(getFloatingHiddenTransform({ mode: "mobile-sheet" })).toBe("translateY(1.8rem) scale(1)");
+		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)");
+		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)");
+		expect(getFloatingHiddenTransform({ mode: "center-selected" })).toBe(
+			"translateY(.45rem) scale(.99)",
+		);
 	});
 
 	test("anchored with no placement", () => {
@@ -67,18 +97,39 @@ describe("getFloatingHiddenTransform", () => {
 	});
 
 	test("anchored with top placement", () => {
-		expect(getFloatingHiddenTransform({ mode: "anchored", placement: "top-left" })).toBe("translateY(.4rem) scale(.975)");
+		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)");
+		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)");
+		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)");
+		expect(getFloatingHiddenTransform({ mode: "anchored", placement: "middle-right" })).toBe(
+			"translateX(-.4rem) scale(.975)",
+		);
+	});
+
+	test("anchored with middle-center placement falls through to default", () => {
+		expect(getFloatingHiddenTransform({ mode: "anchored", placement: "middle-center" })).toBe(
+			"translateY(.4rem) scale(.975)",
+		);
+	});
+
+	test("anchored with middle placement and undefined col falls through", () => {
+		// @ts-expect-error - testing unexpected placement fallthrough
+		expect(getFloatingHiddenTransform({ mode: "anchored", placement: "middle" })).toBe(
+			"translateY(.4rem) scale(.975)",
+		);
 	});
 });

package/tests/utils/keyboardTarget.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "vitest";
+import { describe, expect, test } from "vitest";
 import { isEditableKeyboardTarget } from "@/packages/utils/keyboardTarget";
 
 describe("isEditableKeyboardTarget", () => {
@@ -41,4 +41,45 @@ describe("isEditableKeyboardTarget", () => {
 		const el = document.createElement("div");
 		expect(isEditableKeyboardTarget(el)).toBe(false);
 	});
+
+	test("returns true for SELECT element", () => {
+		const el = document.createElement("select");
+		expect(isEditableKeyboardTarget(el)).toBe(true);
+	});
+
+	test("returns true for email INPUT", () => {
+		const el = document.createElement("input");
+		el.type = "email";
+		expect(isEditableKeyboardTarget(el)).toBe(true);
+	});
+
+	test("returns true for url INPUT", () => {
+		const el = document.createElement("input");
+		el.type = "url";
+		expect(isEditableKeyboardTarget(el)).toBe(true);
+	});
+
+	test("returns true for number INPUT", () => {
+		const el = document.createElement("input");
+		el.type = "number";
+		expect(isEditableKeyboardTarget(el)).toBe(true);
+	});
+
+	test("returns true for password INPUT", () => {
+		const el = document.createElement("input");
+		el.type = "password";
+		expect(isEditableKeyboardTarget(el)).toBe(true);
+	});
+
+	test("returns true for search INPUT", () => {
+		const el = document.createElement("input");
+		el.type = "search";
+		expect(isEditableKeyboardTarget(el)).toBe(true);
+	});
+
+	test("returns true for tel INPUT", () => {
+		const el = document.createElement("input");
+		el.type = "tel";
+		expect(isEditableKeyboardTarget(el)).toBe(true);
+	});
 });

package/tests/utils/mergeRefs.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect, vi } from "vitest";
+import { describe, expect, test, vi } from "vitest";
 import { mergeRefs } from "@/packages/utils/mergeRefs";
 
 describe("mergeRefs", () => {
@@ -15,4 +15,36 @@ describe("mergeRefs", () => {
 		expect(ref1).toHaveBeenCalledWith(element);
 		expect(ref2.current).toBe(element);
 	});
+
+	test("handles all null refs", () => {
+		const merged = mergeRefs(null, undefined, null);
+		const element = document.createElement("div");
+		expect(() => merged(element as any)).not.toThrow();
+	});
+
+	test("handles empty refs array", () => {
+		const merged = mergeRefs();
+		const element = document.createElement("div");
+		expect(() => merged(element as any)).not.toThrow();
+	});
+
+	test("handles all callback refs", () => {
+		const ref1 = vi.fn();
+		const ref2 = vi.fn();
+		const merged = mergeRefs(ref1, ref2);
+		const element = document.createElement("div");
+		merged(element as any);
+		expect(ref1).toHaveBeenCalledWith(element);
+		expect(ref2).toHaveBeenCalledWith(element);
+	});
+
+	test("handles all object refs", () => {
+		const ref1 = { current: null };
+		const ref2 = { current: null };
+		const merged = mergeRefs(ref1, ref2);
+		const element = document.createElement("div");
+		merged(element as any);
+		expect(ref1.current).toBe(element);
+		expect(ref2.current).toBe(element);
+	});
 });

package/tests/utils/seen.test.ts

@@ -1,10 +1,5 @@
-import { describe, test, expect } from "vitest";
-import {
-	parseSeen,
-	hasSeenKey,
-	buildSeenValue,
-	SEEN_STORAGE_KEY,
-} from "@/packages/utils/seen";
+import { describe, expect, test } from "vitest";
+import { buildSeenValue, hasSeenKey, parseSeen, SEEN_STORAGE_KEY } from "@/packages/utils/seen";
 
 describe("seen", () => {
 	test("SEEN_STORAGE_KEY", () => {
@@ -28,4 +23,18 @@ describe("seen", () => {
 		const result = buildSeenValue('{"a":true}', "b");
 		expect(JSON.parse(result)).toEqual({ a: true, b: true });
 	});
+
+	test("parseSeen empty string returns {}", () => {
+		expect(parseSeen("")).toEqual({});
+	});
+
+	test("buildSeenValue with null raw creates fresh object", () => {
+		const result = buildSeenValue(null, "key");
+		expect(JSON.parse(result)).toEqual({ key: true });
+	});
+
+	test("buildSeenValue overrides existing key to true", () => {
+		const result = buildSeenValue('{"key":false}', "key");
+		expect(JSON.parse(result)).toEqual({ key: true });
+	});
 });

package/tests/utils/subscribeKeyboardHeight.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect, vi, beforeEach, afterEach } from "vitest";
+import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
 import { subscribeKeyboardHeight } from "@/packages/utils/subscribeKeyboardHeight";
 
 describe("subscribeKeyboardHeight", () => {
@@ -24,7 +24,9 @@ describe("subscribeKeyboardHeight", () => {
 		});
 	});
 
-	afterEach(() => { vi.useRealTimers(); });
+	afterEach(() => {
+		vi.useRealTimers();
+	});
 
 	test("subscribes to resize events", () => {
 		const callback = vi.fn();
@@ -41,10 +43,130 @@ describe("subscribeKeyboardHeight", () => {
 		expect(callback).toHaveBeenCalled();
 	});
 
+	test("runs synchronously when throttleMs is 0", () => {
+		const callback = vi.fn();
+		subscribeKeyboardHeight({ callback, throttleMs: 0, immediate: true });
+		expect(callback).toHaveBeenCalled();
+	});
+
+	test("skips resize when visualViewport is null", () => {
+		const origVv = window.visualViewport;
+		Object.defineProperty(window, "visualViewport", {
+			value: undefined,
+			writable: true,
+			configurable: true,
+		});
+		const callback = vi.fn();
+		subscribeKeyboardHeight({ callback, immediate: true });
+		expect(callback).not.toHaveBeenCalled();
+		Object.defineProperty(window, "visualViewport", {
+			value: origVv,
+			writable: true,
+			configurable: true,
+		});
+	});
+
+	test("does not call callback when height unchanged", () => {
+		const callback = vi.fn();
+		subscribeKeyboardHeight({ callback, throttleMs: 0, immediate: true });
+		expect(callback).toHaveBeenCalledTimes(1);
+
+		// Trigger resize with the same keyboard height
+		const handler = visualViewport.addEventListener.mock.calls.find(
+			([event]: [string]) => event === "resize",
+		)?.[1] as () => void;
+		if (handler) handler();
+
+		// Same diff (innerHeight 800 - visualViewport.height 600 = 200), so notify(200) again
+		// But lastHeight is already 200, so height !== lastHeight is false
+		expect(callback).toHaveBeenCalledTimes(1);
+	});
+
+	test("handles no keyboard scenario (diff <= 0)", () => {
+		const origInnerHeight = window.innerHeight;
+		// First, call with keyboard raised (diff=200) so lastHeight becomes 200
+		const callback = vi.fn();
+		subscribeKeyboardHeight({ callback, throttleMs: 0, immediate: true });
+		expect(callback).toHaveBeenCalledWith(200);
+		// Now change innerHeight to match visualViewport.height (no keyboard)
+		Object.defineProperty(window, "innerHeight", {
+			value: 600,
+			writable: true,
+			configurable: true,
+		});
+		// Trigger resize handler
+		const resizeHandler = visualViewport.addEventListener.mock.calls.find(
+			([event]: [string]) => event === "resize",
+		)?.[1] as () => void;
+		resizeHandler();
+		// diff = 600 - 600 = 0 → notify(0) → 0 !== 200 → callback(0)
+		expect(callback).toHaveBeenCalledWith(0);
+		Object.defineProperty(window, "innerHeight", {
+			value: origInnerHeight,
+			writable: true,
+			configurable: true,
+		});
+	});
+
+	test("throttles rapid resize events", () => {
+		vi.useFakeTimers();
+		const callback = vi.fn();
+		subscribeKeyboardHeight({ callback, throttleMs: 50 });
+
+		// Simulate two rapid resize events
+		visualViewport.height = 700;
+		visualViewport.addEventListener.mock.calls.forEach(([event, handler]: [string, () => void]) => {
+			if (event === "resize") handler();
+		});
+
+		// Change height again and fire again
+		visualViewport.height = 650;
+		visualViewport.addEventListener.mock.calls.forEach(([event, handler]: [string, () => void]) => {
+			if (event === "resize") handler();
+		});
+
+		// Only the last height should be reported after throttle
+		vi.advanceTimersByTime(50);
+		expect(callback).toHaveBeenCalledTimes(1);
+	});
+
 	test("returns unsubscribe function", () => {
 		const callback = vi.fn();
 		const { unsubscribe } = subscribeKeyboardHeight({ callback });
 		unsubscribe();
 		expect(visualViewport.removeEventListener).toHaveBeenCalled();
 	});
+
+	test("does not call callback after unsubscribe with throttle > 0", () => {
+		vi.useFakeTimers();
+		const callback = vi.fn();
+		const { unsubscribe } = subscribeKeyboardHeight({ callback, throttleMs: 50 });
+
+		// Trigger resize, which schedules a setTimeout
+		visualViewport.height = 400;
+		visualViewport.dispatchEvent?.(new Event("resize"));
+		if (visualViewport.addEventListener.mock.calls.length > 0) {
+			const handler = visualViewport.addEventListener.mock.calls[0][1];
+			handler?.();
+		}
+
+		unsubscribe();
+		vi.advanceTimersByTime(100);
+		expect(callback).not.toHaveBeenCalled();
+	});
+
+	test("does not call callback after unsubscribe with throttle === 0", () => {
+		vi.useFakeTimers();
+		const callback = vi.fn();
+		const { unsubscribe } = subscribeKeyboardHeight({ callback, throttleMs: 0 });
+
+		unsubscribe();
+
+		visualViewport.height = 400;
+		if (visualViewport.addEventListener.mock.calls.length > 0) {
+			const handler = visualViewport.addEventListener.mock.calls[0][1];
+			handler?.();
+		}
+		expect(callback).not.toHaveBeenCalled();
+	});
 });

package/vitest.config.ts

@@ -1,5 +1,5 @@
+import path from "node:path";
 import { defineConfig } from "vitest/config";
-import path from "path";
 
 export default defineConfig({
 	test: {
@@ -7,6 +7,12 @@ export default defineConfig({
 		setupFiles: ["./tests/setup.ts"],
 		include: ["tests/**/*.test.{ts,tsx}"],
 		globals: true,
+		coverage: {
+			provider: "v8",
+			include: ["packages/**/*.{ts,tsx}"],
+			exclude: ["packages/**/*.types.ts"],
+			reporter: ["text", "lcov"],
+		},
 	},
 	resolve: {
 		alias: {