@musecat/functionkit 1.1.0 → 1.2.0

package/tests/utils/clipboardShare.test.ts

@@ -1,152 +0,0 @@
-import { afterEach, describe, expect, test, vi } 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("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,
-			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

@@ -1,135 +0,0 @@
-import { describe, expect, test } from "vitest";
-import {
-	getFloatingHiddenTransform,
-	getFloatingMotionPreset,
-	getFloatingTransformOrigin,
-} 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");
-	});
-
-	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)",
-		);
-	});
-
-	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)",
-		);
-	});
-
-	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,85 +0,0 @@
-import { describe, expect, test } 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);
-	});
-
-	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,50 +0,0 @@
-import { describe, expect, test, vi } from "vitest";
-import { mergeRefs } from "@/packages/utils/mergeRefs";
-
-describe("mergeRefs", () => {
-	test("merges multiple refs", () => {
-		const ref1 = vi.fn();
-		const ref2 = { current: null };
-		const ref3 = null;
-
-		const merged = mergeRefs(ref1, ref2, ref3);
-		const element = document.createElement("div");
-
-		merged(element as any);
-
-		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,40 +0,0 @@
-import { describe, expect, test } from "vitest";
-import { buildSeenValue, hasSeenKey, parseSeen, SEEN_STORAGE_KEY } from "@/packages/utils/seen";
-
-describe("seen", () => {
-	test("SEEN_STORAGE_KEY", () => {
-		expect(SEEN_STORAGE_KEY).toBe("seen");
-	});
-
-	test("parseSeen", () => {
-		expect(parseSeen(null)).toEqual({});
-		expect(parseSeen('{"a":true}')).toEqual({ a: true });
-		expect(parseSeen("invalid json")).toEqual({});
-		expect(parseSeen("[]")).toEqual({});
-	});
-
-	test("hasSeenKey", () => {
-		expect(hasSeenKey('{"a":true}', "a")).toBe(true);
-		expect(hasSeenKey('{"a":true}', "b")).toBe(false);
-		expect(hasSeenKey(null, "a")).toBe(false);
-	});
-
-	test("buildSeenValue", () => {
-		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,172 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
-import { subscribeKeyboardHeight } from "@/packages/utils/subscribeKeyboardHeight";
-
-describe("subscribeKeyboardHeight", () => {
-	let visualViewport: any;
-
-	beforeEach(() => {
-		visualViewport = {
-			height: 600,
-			width: 390,
-			offsetTop: 0,
-			addEventListener: vi.fn(),
-			removeEventListener: vi.fn(),
-		};
-		Object.defineProperty(window, "visualViewport", {
-			value: visualViewport,
-			writable: true,
-			configurable: true,
-		});
-		Object.defineProperty(window, "innerHeight", {
-			value: 800,
-			writable: true,
-			configurable: true,
-		});
-	});
-
-	afterEach(() => {
-		vi.useRealTimers();
-	});
-
-	test("subscribes to resize events", () => {
-		const callback = vi.fn();
-		subscribeKeyboardHeight({ callback });
-		expect(visualViewport.addEventListener).toHaveBeenCalledWith("resize", expect.any(Function));
-		expect(visualViewport.addEventListener).toHaveBeenCalledWith("scroll", expect.any(Function));
-	});
-
-	test("calls immediately when immediate is true", () => {
-		vi.useFakeTimers();
-		const callback = vi.fn();
-		subscribeKeyboardHeight({ callback, immediate: true });
-		vi.advanceTimersByTime(16);
-		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/tsconfig.json

@@ -1,18 +0,0 @@
-{
-	"compilerOptions": {
-		"target": "ES2017",
-		"lib": ["dom", "dom.iterable", "esnext"],
-		"allowJs": true,
-		"skipLibCheck": true,
-		"strict": true,
-		"noEmit": true,
-		"esModuleInterop": true,
-		"module": "esnext",
-		"moduleResolution": "bundler",
-		"resolveJsonModule": true,
-		"isolatedModules": true,
-		"jsx": "react-jsx",
-		"incremental": true
-	},
-	"include": ["**/*.ts", "**/*.tsx"]
-}

package/vitest.config.ts

@@ -1,22 +0,0 @@
-import path from "node:path";
-import { defineConfig } from "vitest/config";
-
-export default defineConfig({
-	test: {
-		environment: "jsdom",
-		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: {
-			"@": path.resolve(__dirname, "./"),
-		},
-	},
-});