@k8ordo/ui 1.0.0

package/dist/helpers/create-safe-context.mjs

@@ -0,0 +1,30 @@
+import { createContext, use } from "react";
+//#region src/helpers/create-safe-context.ts
+const createSafeContext = (errorMessage) => {
+	const Context = createContext(null);
+	const useSafeContext = () => {
+		const value = use(Context);
+		if (value === null) throw new Error(errorMessage);
+		return value;
+	};
+	return [Context, useSafeContext];
+};
+if (import.meta.vitest) describe("createSafeContext", () => {
+	it("Provider配下ではコンテキストの値を返す", async () => {
+		const { createElement } = await import("react");
+		const { renderToString } = await import("react-dom/server");
+		const [Context, useValue] = createSafeContext("missing provider");
+		const Consumer = () => createElement("span", null, useValue());
+		const html = renderToString(createElement(Context, { value: "hello" }, createElement(Consumer)));
+		expect(html).toContain("hello");
+	});
+	it("Provider外では指定したエラーメッセージでthrowする", async () => {
+		const { createElement } = await import("react");
+		const { renderToString } = await import("react-dom/server");
+		const [, useValue] = createSafeContext("useValue must be used within a Provider");
+		const Consumer = () => createElement("span", null, useValue());
+		expect(() => renderToString(createElement(Consumer))).toThrow("useValue must be used within a Provider");
+	});
+});
+//#endregion
+export { createSafeContext };

package/dist/helpers/index.d.mts

@@ -0,0 +1,6 @@
+import { chain } from "./chain.mjs";
+import { cn } from "./cn.mjs";
+import { createSafeContext } from "./create-safe-context.mjs";
+import { mergeProps } from "./merge-props.mjs";
+import { mergeRefs } from "./merge-refs.mjs";
+export { chain, cn, createSafeContext, mergeProps, mergeRefs };

package/dist/helpers/index.mjs

@@ -0,0 +1,6 @@
+import { cn } from "./cn.mjs";
+import { chain } from "./chain.mjs";
+import { createSafeContext } from "./create-safe-context.mjs";
+import { mergeProps } from "./merge-props.mjs";
+import { mergeRefs } from "./merge-refs.mjs";
+export { chain, cn, createSafeContext, mergeProps, mergeRefs };

package/dist/helpers/merge-props.d.mts

@@ -0,0 +1,6 @@
+//#region src/helpers/merge-props.d.ts
+type Props = Record<string, unknown>;
+type MergedProps<A, B> = Omit<A, keyof B> & B;
+declare const mergeProps: <A extends Props, B extends Props>(base: A, override: B) => MergedProps<A, B>;
+//#endregion
+export { mergeProps };

package/dist/helpers/merge-props.mjs

@@ -0,0 +1,56 @@
+import { cn } from "./cn.mjs";
+import { chain } from "./chain.mjs";
+//#region src/helpers/merge-props.ts
+const isEventHandler = (key, value) => typeof value === "function" && key.startsWith("on") && key.length > 2 && key[2] === (key[2]?.toUpperCase() ?? "");
+const mergeProps = (base, override) => {
+	const result = { ...base };
+	for (const key of Object.keys(override)) {
+		const baseValue = base[key];
+		const overrideValue = override[key];
+		if (key === "className") result[key] = cn(baseValue, overrideValue);
+		else if (key === "style") result[key] = {
+			...baseValue,
+			...overrideValue
+		};
+		else if (isEventHandler(key, baseValue) && isEventHandler(key, overrideValue)) result[key] = chain(baseValue, overrideValue);
+		else if (overrideValue !== void 0) result[key] = overrideValue;
+	}
+	return result;
+};
+if (import.meta.vitest) describe("mergeProps", () => {
+	it("classNameをcnでマージする", () => {
+		const merged = mergeProps({ className: "p-2 text-fg-base" }, { className: "text-fg-mute" });
+		expect(merged.className).toBe("p-2 text-fg-mute");
+	});
+	it("styleを浅くマージする", () => {
+		const merged = mergeProps({ style: {
+			color: "red",
+			fontSize: 12
+		} }, { style: { color: "blue" } });
+		expect(merged.style).toEqual({
+			color: "blue",
+			fontSize: 12
+		});
+	});
+	it("onClickなどのイベントハンドラを連結する", () => {
+		const calls = [];
+		mergeProps({ onClick: () => calls.push("a") }, { onClick: () => calls.push("b") }).onClick();
+		expect(calls).toEqual(["a", "b"]);
+	});
+	it("それ以外のpropsは後勝ちで上書きする", () => {
+		const merged = mergeProps({
+			id: "a",
+			disabled: true
+		}, { id: "b" });
+		expect(merged).toEqual({
+			id: "b",
+			disabled: true
+		});
+	});
+	it("overrideがundefinedの場合はbaseの値を保持する", () => {
+		const merged = mergeProps({ id: "a" }, { id: void 0 });
+		expect(merged.id).toBe("a");
+	});
+});
+//#endregion
+export { mergeProps };

package/dist/helpers/merge-refs.d.mts

@@ -0,0 +1,5 @@
+import { Ref, RefCallback } from "react";
+//#region src/helpers/merge-refs.d.ts
+declare const mergeRefs: <T>(...refs: ReadonlyArray<Ref<T> | undefined>) => RefCallback<T>;
+//#endregion
+export { mergeRefs };

package/dist/helpers/merge-refs.mjs

@@ -0,0 +1,55 @@
+//#region src/helpers/merge-refs.ts
+const mergeRefs = (...refs) => (value) => {
+	const cleanups = [];
+	for (const ref of refs) if (typeof ref === "function") {
+		const result = ref(value);
+		if (typeof result === "function") cleanups.push(() => {
+			result();
+		});
+		else cleanups.push(() => {
+			ref(null);
+		});
+	} else if (ref !== null && ref !== void 0) {
+		ref.current = value;
+		cleanups.push(() => {
+			ref.current = null;
+		});
+	}
+	return () => {
+		for (const cleanup of cleanups) cleanup();
+	};
+};
+if (import.meta.vitest) describe("mergeRefs", () => {
+	it("オブジェクトrefと関数refの両方に値を設定する", () => {
+		const objectRef = { current: null };
+		const functionRef = vi.fn();
+		const element = {};
+		mergeRefs(objectRef, functionRef)(element);
+		expect(objectRef.current).toBe(element);
+		expect(functionRef).toHaveBeenCalledWith(element);
+	});
+	it("nullとundefinedのrefをスキップする", () => {
+		const objectRef = { current: null };
+		const element = {};
+		const cleanup = mergeRefs(null, void 0, objectRef)(element);
+		expect(objectRef.current).toBe(element);
+		expect(cleanup).toBeTypeOf("function");
+	});
+	it("クリーンアップでオブジェクトrefをnullに戻し、関数refをnullで呼ぶ", () => {
+		const objectRef = { current: null };
+		const functionRef = vi.fn();
+		mergeRefs(objectRef, functionRef)({})?.();
+		expect(objectRef.current).toBeNull();
+		expect(functionRef).toHaveBeenLastCalledWith(null);
+	});
+	it("クリーンアップ関数を返す関数refは、nullで再呼び出しせずそのクリーンアップを実行する", () => {
+		const refCleanup = vi.fn();
+		const functionRef = vi.fn(() => refCleanup);
+		mergeRefs(functionRef)({})?.();
+		expect(refCleanup).toHaveBeenCalledOnce();
+		expect(functionRef).toHaveBeenCalledOnce();
+		expect(functionRef).not.toHaveBeenCalledWith(null);
+	});
+});
+//#endregion
+export { mergeRefs };

package/dist/hooks/breakpoint/index.d.mts

@@ -0,0 +1,5 @@
+//#region src/hooks/breakpoint/index.d.ts
+type Breakpoint = 'sm' | 'md' | 'lg' | 'xl' | '2xl';
+declare const useBreakpoint: (breakpoint: Breakpoint) => boolean;
+//#endregion
+export { useBreakpoint };

package/dist/hooks/breakpoint/index.mjs

@@ -0,0 +1,24 @@
+"use client";
+import { useCallback, useSyncExternalStore } from "react";
+//#region src/hooks/breakpoint/index.ts
+const BREAKPOINTS = {
+	sm: "40rem",
+	md: "48rem",
+	lg: "64rem",
+	xl: "80rem",
+	"2xl": "96rem"
+};
+const useBreakpoint = (breakpoint) => {
+	const query = `(min-width: ${BREAKPOINTS[breakpoint]})`;
+	const subscribe = useCallback((cb) => {
+		const mediaQueryList = window.matchMedia(query);
+		mediaQueryList.addEventListener("change", cb);
+		return () => {
+			mediaQueryList.removeEventListener("change", cb);
+		};
+	}, [query]);
+	const getSnapshot = () => window.matchMedia(query).matches;
+	return useSyncExternalStore(subscribe, getSnapshot, () => false);
+};
+//#endregion
+export { useBreakpoint };

package/dist/hooks/click-away/index.d.mts

@@ -0,0 +1,5 @@
+import { RefObject } from "react";
+//#region src/hooks/click-away/index.d.ts
+declare const useClickAway: <T extends Element = HTMLElement>(ref: RefObject<T | null>, callback: (e: Event) => void, enabled?: boolean) => void;
+//#endregion
+export { useClickAway };

package/dist/hooks/click-away/index.mjs

@@ -0,0 +1,24 @@
+"use client";
+import { useEffect } from "react";
+//#region src/hooks/click-away/index.ts
+const useClickAway = (ref, callback, enabled = true) => {
+	useEffect(() => {
+		if (!enabled) return void 0;
+		const handler = (e) => {
+			const element = ref.current;
+			if (element && e.target instanceof Node && !element.contains(e.target)) callback(e);
+		};
+		document.addEventListener("mousedown", handler);
+		document.addEventListener("touchstart", handler, { passive: true });
+		return () => {
+			document.removeEventListener("mousedown", handler);
+			document.removeEventListener("touchstart", handler);
+		};
+	}, [
+		ref,
+		callback,
+		enabled
+	]);
+};
+//#endregion
+export { useClickAway };

package/dist/hooks/client/index.d.mts

@@ -0,0 +1,4 @@
+//#region src/hooks/client/index.d.ts
+declare const useClient: () => boolean;
+//#endregion
+export { useClient };

package/dist/hooks/client/index.mjs

@@ -0,0 +1,6 @@
+"use client";
+import { useSyncExternalStore } from "react";
+//#region src/hooks/client/index.ts
+const useClient = () => useSyncExternalStore(() => () => {}, () => true, () => false);
+//#endregion
+export { useClient };

package/dist/hooks/clipboard/index.d.mts

@@ -0,0 +1,7 @@
+//#region src/hooks/clipboard/index.d.ts
+declare const useClipboard: () => {
+  writeClipboard: (text: string) => Promise<void>;
+  readClipboard: () => Promise<string>;
+};
+//#endregion
+export { useClipboard };

package/dist/hooks/clipboard/index.mjs

@@ -0,0 +1,15 @@
+"use client";
+import { useCallback } from "react";
+//#region src/hooks/clipboard/index.ts
+const useClipboard = () => {
+	return {
+		writeClipboard: useCallback(async (text) => {
+			await navigator.clipboard.writeText(text);
+		}, []),
+		readClipboard: useCallback(async () => {
+			return await navigator.clipboard.readText();
+		}, [])
+	};
+};
+//#endregion
+export { useClipboard };

package/dist/hooks/controllable-state/index.d.mts

@@ -0,0 +1,9 @@
+//#region src/hooks/controllable-state/index.d.ts
+type UseControllableStateProps<T> = {
+  value?: T;
+  defaultValue: T;
+  onChange?: (value: T) => void;
+};
+declare const useControllableState: <T>({ value, defaultValue, onChange }: UseControllableStateProps<T>) => [T, (next: T | ((prev: T) => T)) => void];
+//#endregion
+export { useControllableState };

package/dist/hooks/controllable-state/index.mjs

@@ -0,0 +1,21 @@
+"use client";
+import { useCallback, useRef, useState } from "react";
+//#region src/hooks/controllable-state/index.ts
+const useControllableState = ({ value, defaultValue, onChange }) => {
+	const isControlled = value !== void 0;
+	const [internalValue, setInternalValue] = useState(defaultValue);
+	const currentValue = isControlled ? value : internalValue;
+	const currentValueRef = useRef(currentValue);
+	currentValueRef.current = currentValue;
+	const onChangeRef = useRef(onChange);
+	onChangeRef.current = onChange;
+	const isControlledRef = useRef(isControlled);
+	isControlledRef.current = isControlled;
+	return [currentValue, useCallback((next) => {
+		const nextValue = typeof next === "function" ? next(currentValueRef.current) : next;
+		if (!isControlledRef.current) setInternalValue(nextValue);
+		onChangeRef.current?.(nextValue);
+	}, [])];
+};
+//#endregion
+export { useControllableState };

package/dist/hooks/debounced-transition/index.d.mts

@@ -0,0 +1,5 @@
+//#region src/hooks/debounced-transition/index.d.ts
+type DebouncedAction = (signal: AbortSignal) => void | Promise<void>;
+declare const useDebouncedTransition: (delay: number) => readonly [boolean, (action: DebouncedAction) => void];
+//#endregion
+export { DebouncedAction, useDebouncedTransition };

package/dist/hooks/debounced-transition/index.mjs

@@ -0,0 +1,49 @@
+"use client";
+import { useCallback, useEffect, useRef, useTransition } from "react";
+//#region src/hooks/debounced-transition/index.ts
+const useDebouncedTransition = (delay) => {
+	const [isPending, startTransition] = useTransition();
+	const abortRef = useRef(null);
+	useEffect(() => () => {
+		abortRef.current?.abort();
+	}, []);
+	return [isPending, useCallback((action) => {
+		abortRef.current?.abort();
+		const controller = new AbortController();
+		abortRef.current = controller;
+		const { signal } = controller;
+		startTransition(async () => {
+			try {
+				await delayWithSignal(delay, signal);
+			} catch {
+				return;
+			}
+			if (signal.aborted) return;
+			try {
+				await action(signal);
+			} catch (error) {
+				if (isAbortError(error)) return;
+				throw error;
+			}
+		});
+	}, [delay])];
+};
+const toAbortError = (reason) => reason instanceof Error ? reason : new DOMException("aborted", "AbortError");
+const delayWithSignal = (ms, signal) => new Promise((resolve, reject) => {
+	if (signal.aborted) {
+		reject(toAbortError(signal.reason));
+		return;
+	}
+	const timer = setTimeout(resolve, ms);
+	signal.addEventListener("abort", () => {
+		clearTimeout(timer);
+		reject(toAbortError(signal.reason));
+	}, { once: true });
+});
+const isAbortError = (error) => {
+	if (error instanceof DOMException && error.name === "AbortError") return true;
+	if (error instanceof Error && error.name === "AbortError") return true;
+	return false;
+};
+//#endregion
+export { useDebouncedTransition };

package/dist/hooks/deferred-debounce/index.d.mts

@@ -0,0 +1,4 @@
+//#region src/hooks/deferred-debounce/index.d.ts
+declare const useDeferredDebounce: <T>(value: T, initialValue?: T) => readonly [T, boolean];
+//#endregion
+export { useDeferredDebounce };

package/dist/hooks/deferred-debounce/index.mjs

@@ -0,0 +1,9 @@
+"use client";
+import { useDeferredValue } from "react";
+//#region src/hooks/deferred-debounce/index.ts
+const useDeferredDebounce = (value, initialValue) => {
+	const deferredValue = useDeferredValue(value, initialValue);
+	return [deferredValue, !Object.is(deferredValue, value)];
+};
+//#endregion
+export { useDeferredDebounce };

package/dist/hooks/disclosure/index.d.mts

@@ -0,0 +1,10 @@
+//#region src/hooks/disclosure/index.d.ts
+type UseDisclosureReturn = {
+  isOpen: boolean;
+  open: () => void;
+  close: () => void;
+  toggle: () => void;
+};
+declare const useDisclosure: (defaultOpen?: boolean) => UseDisclosureReturn;
+//#endregion
+export { useDisclosure };

package/dist/hooks/disclosure/index.mjs

@@ -0,0 +1,20 @@
+"use client";
+import { useCallback, useState } from "react";
+//#region src/hooks/disclosure/index.ts
+const useDisclosure = (defaultOpen = false) => {
+	const [isOpen, setIsOpen] = useState(defaultOpen);
+	return {
+		isOpen,
+		open: useCallback(() => {
+			setIsOpen(true);
+		}, []),
+		close: useCallback(() => {
+			setIsOpen(false);
+		}, []),
+		toggle: useCallback(() => {
+			setIsOpen((prev) => !prev);
+		}, [])
+	};
+};
+//#endregion
+export { useDisclosure };

package/dist/hooks/focus-trap/index.d.mts

@@ -0,0 +1,18 @@
+import { RefObject } from "react";
+//#region src/hooks/focus-trap/index.d.ts
+/**
+ * 非モーダルなポップアップのフォーカス管理。
+ *
+ * floating-ui の `<FloatingFocusManager modal={false}>` 相当を自前で再現する:
+ * - 開いたとき、ポップアップ内へ初期フォーカスを移す
+ *   （内部に roving tabindex のリストがある場合は、そのリストナビゲーション側の
+ *   フォーカスが後で上書きするため、ここではコンテナ/先頭要素に当てるだけでよい）
+ * - 閉じたとき、フォーカスがまだポップアップ内（または喪失）していればトリガーへ戻す。
+ *   外側を意図的にクリック/フォーカスした場合は奪い返さない。
+ *
+ * ハードな Tab トラップや close-on-focus-out は行わない（元実装が modal=false のため）。
+ * 外側クリック / Escape による dismiss は呼び出し側が担う。
+ */
+declare const useFocusTrap: (contentRef: RefObject<HTMLElement | null>, triggerRef: RefObject<Element | null>, enabled: boolean) => void;
+//#endregion
+export { useFocusTrap };

package/dist/hooks/focus-trap/index.mjs

@@ -0,0 +1,51 @@
+"use client";
+import { useEffect } from "react";
+//#region src/hooks/focus-trap/index.ts
+const FOCUSABLE_SELECTOR = [
+	"a[href]",
+	"button:not([disabled])",
+	"input:not([disabled])",
+	"select:not([disabled])",
+	"textarea:not([disabled])",
+	"[tabindex]:not([tabindex=\"-1\"])",
+	"[contenteditable=\"true\"]"
+].join(",");
+/**
+* 非モーダルなポップアップのフォーカス管理。
+*
+* floating-ui の `<FloatingFocusManager modal={false}>` 相当を自前で再現する:
+* - 開いたとき、ポップアップ内へ初期フォーカスを移す
+*   （内部に roving tabindex のリストがある場合は、そのリストナビゲーション側の
+*   フォーカスが後で上書きするため、ここではコンテナ/先頭要素に当てるだけでよい）
+* - 閉じたとき、フォーカスがまだポップアップ内（または喪失）していればトリガーへ戻す。
+*   外側を意図的にクリック/フォーカスした場合は奪い返さない。
+*
+* ハードな Tab トラップや close-on-focus-out は行わない（元実装が modal=false のため）。
+* 外側クリック / Escape による dismiss は呼び出し側が担う。
+*/
+const useFocusTrap = (contentRef, triggerRef, enabled) => {
+	useEffect(() => {
+		if (!enabled) return;
+		const content = contentRef.current;
+		if (!content) return;
+		const trigger = triggerRef.current;
+		if (!content.contains(document.activeElement)) {
+			const first = content.querySelector(FOCUSABLE_SELECTOR);
+			if (first) first.focus();
+			else {
+				content.tabIndex = -1;
+				content.focus();
+			}
+		}
+		return () => {
+			const active = document.activeElement;
+			if ((active === null || active === document.body || content.contains(active)) && trigger instanceof HTMLElement) trigger.focus();
+		};
+	}, [
+		contentRef,
+		triggerRef,
+		enabled
+	]);
+};
+//#endregion
+export { useFocusTrap };

package/dist/hooks/hash/index.d.mts

@@ -0,0 +1,4 @@
+//#region src/hooks/hash/index.d.ts
+declare const useHash: () => string | null;
+//#endregion
+export { useHash };

package/dist/hooks/hash/index.mjs

@@ -0,0 +1,25 @@
+"use client";
+import { useSyncExternalStore } from "react";
+//#region src/hooks/hash/index.ts
+const getHash = () => typeof window === "undefined" ? null : decodeURIComponent(window.location.hash.replace("#", ""));
+const subscribe = (callback) => {
+	const originalPushState = window.history.pushState.bind(window.history);
+	const originalReplaceState = window.history.replaceState.bind(window.history);
+	window.history.pushState = (...args) => {
+		originalPushState(...args);
+		setTimeout(callback);
+	};
+	window.history.replaceState = (...args) => {
+		originalReplaceState(...args);
+		setTimeout(callback);
+	};
+	window.addEventListener("hashchange", callback);
+	return () => {
+		window.removeEventListener("hashchange", callback);
+	};
+};
+const useHash = () => {
+	return useSyncExternalStore(subscribe, () => getHash(), () => null);
+};
+//#endregion
+export { useHash };

package/dist/hooks/hover/index.d.mts

@@ -0,0 +1,12 @@
+//#region src/hooks/hover/index.d.ts
+type HoverProps = {
+  onPointerEnter: () => void;
+  onPointerLeave: () => void;
+};
+type UseHoverReturn = {
+  isHovered: boolean;
+  hoverProps: HoverProps;
+};
+declare const useHover: () => UseHoverReturn;
+//#endregion
+export { useHover };

package/dist/hooks/hover/index.mjs

@@ -0,0 +1,19 @@
+"use client";
+import { useCallback, useState } from "react";
+//#region src/hooks/hover/index.ts
+const useHover = () => {
+	const [isHovered, setIsHovered] = useState(false);
+	return {
+		isHovered,
+		hoverProps: {
+			onPointerEnter: useCallback(() => {
+				setIsHovered(true);
+			}, []),
+			onPointerLeave: useCallback(() => {
+				setIsHovered(false);
+			}, [])
+		}
+	};
+};
+//#endregion
+export { useHover };

package/dist/hooks/index.d.mts

@@ -0,0 +1,25 @@
+import { useBreakpoint } from "./breakpoint/index.mjs";
+import { useClickAway } from "./click-away/index.mjs";
+import { useClient } from "./client/index.mjs";
+import { useClipboard } from "./clipboard/index.mjs";
+import { useControllableState } from "./controllable-state/index.mjs";
+import { DebouncedAction, useDebouncedTransition } from "./debounced-transition/index.mjs";
+import { useDeferredDebounce } from "./deferred-debounce/index.mjs";
+import { useDisclosure } from "./disclosure/index.mjs";
+import { useHash } from "./hash/index.mjs";
+import { useHover } from "./hover/index.mjs";
+import { useIntersectionObserver } from "./intersection-observer/use-intersection-observer.mjs";
+import { useInView } from "./intersection-observer/use-in-view.mjs";
+import "./intersection-observer/index.mjs";
+import { useInterval } from "./interval/index.mjs";
+import { useLocalStorage } from "./local-storage/index.mjs";
+import { useResize } from "./resize/index.mjs";
+import { useScrollDirection } from "./scroll-direction/index.mjs";
+import { useScrollLock } from "./scroll-lock/index.mjs";
+import { useSessionStorage } from "./session-storage/index.mjs";
+import { useStep } from "./step/index.mjs";
+import { useTimeout } from "./timeout/index.mjs";
+import { useWindowResize } from "./window-resize/index.mjs";
+import { useWindowSize } from "./window-size/index.mjs";
+import { WritingMode, useWritingMode } from "./writing-mode/index.mjs";
+export { type DebouncedAction, type WritingMode, useBreakpoint, useClickAway, useClient, useClipboard, useControllableState, useDebouncedTransition, useDeferredDebounce, useDisclosure, useHash, useHover, useInView, useIntersectionObserver, useInterval, useLocalStorage, useResize, useScrollDirection, useScrollLock, useSessionStorage, useStep, useTimeout, useWindowResize, useWindowSize, useWritingMode };

package/dist/hooks/index.mjs

@@ -0,0 +1,24 @@
+import { useClickAway } from "./click-away/index.mjs";
+import { useClient } from "./client/index.mjs";
+import { useClipboard } from "./clipboard/index.mjs";
+import { useControllableState } from "./controllable-state/index.mjs";
+import { useDebouncedTransition } from "./debounced-transition/index.mjs";
+import { useDeferredDebounce } from "./deferred-debounce/index.mjs";
+import { useDisclosure } from "./disclosure/index.mjs";
+import { useHash } from "./hash/index.mjs";
+import { useHover } from "./hover/index.mjs";
+import { useIntersectionObserver } from "./intersection-observer/use-intersection-observer.mjs";
+import { useInView } from "./intersection-observer/use-in-view.mjs";
+import { useInterval } from "./interval/index.mjs";
+import { useBreakpoint } from "./breakpoint/index.mjs";
+import { useLocalStorage } from "./local-storage/index.mjs";
+import { useResize } from "./resize/index.mjs";
+import { useScrollDirection } from "./scroll-direction/index.mjs";
+import { useScrollLock } from "./scroll-lock/index.mjs";
+import { useSessionStorage } from "./session-storage/index.mjs";
+import { useStep } from "./step/index.mjs";
+import { useTimeout } from "./timeout/index.mjs";
+import { useWindowResize } from "./window-resize/index.mjs";
+import { useWindowSize } from "./window-size/index.mjs";
+import { useWritingMode } from "./writing-mode/index.mjs";
+export { useBreakpoint, useClickAway, useClient, useClipboard, useControllableState, useDebouncedTransition, useDeferredDebounce, useDisclosure, useHash, useHover, useInView, useIntersectionObserver, useInterval, useLocalStorage, useResize, useScrollDirection, useScrollLock, useSessionStorage, useStep, useTimeout, useWindowResize, useWindowSize, useWritingMode };

package/dist/hooks/intersection-observer/index.d.mts

@@ -0,0 +1,3 @@
+import { useIntersectionObserver } from "./use-intersection-observer.mjs";
+import { useInView } from "./use-in-view.mjs";
+export { useInView, useIntersectionObserver };

package/dist/hooks/intersection-observer/index.mjs

@@ -0,0 +1,3 @@
+import { useIntersectionObserver } from "./use-intersection-observer.mjs";
+import { useInView } from "./use-in-view.mjs";
+export { useInView, useIntersectionObserver };

package/dist/hooks/intersection-observer/use-in-view.d.mts

@@ -0,0 +1,11 @@
+import { RefObject } from "react";
+//#region src/hooks/intersection-observer/use-in-view.d.ts
+type UseInViewOptions = {
+  threshold?: number | number[];
+  root?: Element | null;
+  rootMargin?: string;
+  once?: boolean;
+};
+declare const useInView: <T extends Element = HTMLElement>(ref: RefObject<T | null>, options?: UseInViewOptions) => boolean;
+//#endregion
+export { useInView };

package/dist/hooks/intersection-observer/use-in-view.mjs

@@ -0,0 +1,18 @@
+"use client";
+import { useIntersectionObserver } from "./use-intersection-observer.mjs";
+import { useCallback, useState } from "react";
+//#region src/hooks/intersection-observer/use-in-view.ts
+const useInView = (ref, options = {}) => {
+	const { once = false, ...observerOptions } = options;
+	const [isInView, setIsInView] = useState(false);
+	const handleEntry = useCallback((entry) => {
+		setIsInView(entry.isIntersecting);
+	}, []);
+	useIntersectionObserver(ref, handleEntry, {
+		...observerOptions,
+		once
+	});
+	return isInView;
+};
+//#endregion
+export { useInView };