@k8ordo/ui 1.0.0

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

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

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

@@ -0,0 +1,33 @@
+"use client";
+import { useEffect } from "react";
+//#region src/hooks/intersection-observer/use-intersection-observer.ts
+const useIntersectionObserver = (ref, callback, options = {}) => {
+	const { threshold = 0, root = null, rootMargin = "0px", once = false } = options;
+	useEffect(() => {
+		const element = ref.current;
+		if (!element) return void 0;
+		const observer = new IntersectionObserver(([entry]) => {
+			if (entry) {
+				callback(entry);
+				if (once && entry.isIntersecting) observer.disconnect();
+			}
+		}, {
+			threshold,
+			root,
+			rootMargin
+		});
+		observer.observe(element);
+		return () => {
+			observer.disconnect();
+		};
+	}, [
+		ref,
+		callback,
+		threshold,
+		root,
+		rootMargin,
+		once
+	]);
+};
+//#endregion
+export { useIntersectionObserver };

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

@@ -0,0 +1,4 @@
+//#region src/hooks/interval/index.d.ts
+declare const useInterval: (callback: () => void, timeout: number) => void;
+//#endregion
+export { useInterval };

package/dist/hooks/interval/index.mjs

@@ -0,0 +1,19 @@
+"use client";
+import { useEffect, useRef } from "react";
+//#region src/hooks/interval/index.ts
+const useInterval = (callback, timeout) => {
+	const callbackRef = useRef(callback);
+	useEffect(() => {
+		callbackRef.current = callback;
+	});
+	useEffect(() => {
+		const intervalId = window.setInterval(() => {
+			callbackRef.current();
+		}, timeout);
+		return () => {
+			window.clearInterval(intervalId);
+		};
+	}, [timeout]);
+};
+//#endregion
+export { useInterval };

package/dist/hooks/local-storage/index.d.mts

@@ -0,0 +1,4 @@
+//#region src/hooks/local-storage/index.d.ts
+declare const useLocalStorage: <T>(key: string, initialValue: T) => readonly [T, (value: T) => void, () => void];
+//#endregion
+export { useLocalStorage };

package/dist/hooks/local-storage/index.mjs

@@ -0,0 +1,46 @@
+"use client";
+import { useCallback, useMemo, useRef, useSyncExternalStore } from "react";
+//#region src/hooks/local-storage/index.ts
+const dispatchStorageEvent = (key, newValue) => window.dispatchEvent(new StorageEvent("storage", {
+	key,
+	newValue
+}));
+const getLocalStorageItem = (key) => window.localStorage.getItem(key);
+const localStorageSubscribe = (cb) => {
+	window.addEventListener("storage", cb);
+	return () => {
+		window.removeEventListener("storage", cb);
+	};
+};
+const useLocalStorage = (key, initialValue) => {
+	const initialValueRef = useRef(initialValue);
+	const getSnapshot = () => getLocalStorageItem(key);
+	const store = useSyncExternalStore(localStorageSubscribe, getSnapshot, () => null);
+	const current = useMemo(() => {
+		try {
+			if (store === null) return initialValueRef.current;
+			return JSON.parse(store);
+		} catch (e) {
+			console.error(e);
+			return initialValueRef.current;
+		}
+	}, [store]);
+	const handleRemove = useCallback(() => {
+		window.localStorage.removeItem(key);
+		dispatchStorageEvent(key, null);
+	}, [key]);
+	return [
+		current,
+		useCallback((value) => {
+			if (value === void 0 || value === null) handleRemove();
+			else {
+				const stringifiedValue = JSON.stringify(value);
+				window.localStorage.setItem(key, stringifiedValue);
+				dispatchStorageEvent(key, stringifiedValue);
+			}
+		}, [key, handleRemove]),
+		handleRemove
+	];
+};
+//#endregion
+export { useLocalStorage };

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

@@ -0,0 +1,8 @@
+import { RefObject } from "react";
+//#region src/hooks/resize/index.d.ts
+type Options = {
+  enabled?: boolean;
+};
+declare const useResize: <T extends Element = HTMLElement>(ref: RefObject<T | null>, callback: (entry: ResizeObserverEntry) => void, options?: Options) => void;
+//#endregion
+export { useResize };

package/dist/hooks/resize/index.mjs

@@ -0,0 +1,24 @@
+"use client";
+import { useEffect } from "react";
+//#region src/hooks/resize/index.ts
+const useResize = (ref, callback, options = {}) => {
+	const { enabled = true } = options;
+	useEffect(() => {
+		if (!enabled) return void 0;
+		const element = ref.current;
+		if (!element) return void 0;
+		const observer = new ResizeObserver((entries) => {
+			for (const entry of entries) callback(entry);
+		});
+		observer.observe(element);
+		return () => {
+			observer.disconnect();
+		};
+	}, [
+		ref,
+		callback,
+		enabled
+	]);
+};
+//#endregion
+export { useResize };

package/dist/hooks/scroll-direction/index.d.mts

@@ -0,0 +1,13 @@
+import { RefObject } from "react";
+//#region src/hooks/scroll-direction/index.d.ts
+type ScrollDirection = {
+  x: 'left' | 'right';
+  y: 'up' | 'down';
+};
+type UseScrollDirectionOptions = {
+  threshold?: number;
+  target?: RefObject<HTMLElement | null>;
+};
+declare const useScrollDirection: (options?: UseScrollDirectionOptions) => ScrollDirection;
+//#endregion
+export { useScrollDirection };

package/dist/hooks/scroll-direction/index.mjs

@@ -0,0 +1,67 @@
+"use client";
+import { useCallback, useRef, useSyncExternalStore } from "react";
+//#region src/hooks/scroll-direction/index.ts
+const SERVER_SNAPSHOT = {
+	x: "right",
+	y: "up"
+};
+const getServerSnapshot = () => SERVER_SNAPSHOT;
+const useScrollDirection = (options = {}) => {
+	const { threshold = 50, target } = options;
+	const stateRef = useRef({
+		direction: {
+			x: "right",
+			y: "up"
+		},
+		prevScrollX: 0,
+		prevScrollY: 0
+	});
+	const subscribe = useCallback((callback) => {
+		const element = target?.current ?? null;
+		const eventTarget = element ?? window;
+		const getScroll = () => {
+			if (element) return {
+				x: element.scrollLeft,
+				y: element.scrollTop
+			};
+			return {
+				x: window.scrollX,
+				y: window.scrollY
+			};
+		};
+		const handleScroll = () => {
+			const { x: currentScrollX, y: currentScrollY } = getScroll();
+			const state = stateRef.current;
+			let changed = false;
+			const newDirection = { ...state.direction };
+			if (currentScrollY > state.prevScrollY && currentScrollY > threshold && newDirection.y !== "down") {
+				newDirection.y = "down";
+				changed = true;
+			} else if (currentScrollY < state.prevScrollY && newDirection.y !== "up") {
+				newDirection.y = "up";
+				changed = true;
+			}
+			if (currentScrollX > state.prevScrollX && currentScrollX > threshold && newDirection.x !== "right") {
+				newDirection.x = "right";
+				changed = true;
+			} else if (currentScrollX < state.prevScrollX && newDirection.x !== "left") {
+				newDirection.x = "left";
+				changed = true;
+			}
+			stateRef.current = {
+				direction: newDirection,
+				prevScrollX: currentScrollX,
+				prevScrollY: currentScrollY
+			};
+			if (changed) callback();
+		};
+		eventTarget.addEventListener("scroll", handleScroll, { passive: true });
+		return () => {
+			eventTarget.removeEventListener("scroll", handleScroll);
+		};
+	}, [threshold, target]);
+	const getSnapshot = () => stateRef.current.direction;
+	return useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
+};
+//#endregion
+export { useScrollDirection };

package/dist/hooks/scroll-lock/index.d.mts

@@ -0,0 +1,9 @@
+import { RefObject } from "react";
+//#region src/hooks/scroll-lock/index.d.ts
+type UseScrollLockReturn = {
+  lock: () => void;
+  unlock: () => void;
+};
+declare const useScrollLock: (target?: RefObject<HTMLElement | null>) => UseScrollLockReturn;
+//#endregion
+export { useScrollLock };

package/dist/hooks/scroll-lock/index.mjs

@@ -0,0 +1,59 @@
+"use client";
+import { useCallback, useEffect, useRef } from "react";
+//#region src/hooks/scroll-lock/index.ts
+const lockRegistry = /* @__PURE__ */ new WeakMap();
+const resolveTarget = (target) => target?.current ?? document.body;
+const useScrollLock = (target) => {
+	const isLockedRef = useRef(false);
+	const lockedElementRef = useRef(null);
+	const lock = useCallback(() => {
+		if (isLockedRef.current) return;
+		const element = resolveTarget(target);
+		isLockedRef.current = true;
+		lockedElementRef.current = element;
+		const entry = lockRegistry.get(element);
+		if (entry) entry.count++;
+		else {
+			lockRegistry.set(element, {
+				count: 1,
+				originalOverflow: element.style.overflow
+			});
+			element.style.overflow = "hidden";
+		}
+	}, [target]);
+	const unlock = useCallback(() => {
+		if (!isLockedRef.current) return;
+		const element = lockedElementRef.current;
+		if (!element) return;
+		isLockedRef.current = false;
+		lockedElementRef.current = null;
+		const entry = lockRegistry.get(element);
+		if (!entry) return;
+		entry.count--;
+		if (entry.count === 0) {
+			element.style.overflow = entry.originalOverflow;
+			lockRegistry.delete(element);
+		}
+	}, []);
+	useEffect(() => () => {
+		if (isLockedRef.current) {
+			const element = lockedElementRef.current;
+			isLockedRef.current = false;
+			lockedElementRef.current = null;
+			if (!element) return;
+			const entry = lockRegistry.get(element);
+			if (!entry) return;
+			entry.count--;
+			if (entry.count === 0) {
+				element.style.overflow = entry.originalOverflow;
+				lockRegistry.delete(element);
+			}
+		}
+	}, []);
+	return {
+		lock,
+		unlock
+	};
+};
+//#endregion
+export { useScrollLock };

package/dist/hooks/session-storage/index.d.mts

@@ -0,0 +1,4 @@
+//#region src/hooks/session-storage/index.d.ts
+declare const useSessionStorage: <T>(key: string, initialValue: T) => readonly [T, (value: T) => void, () => void];
+//#endregion
+export { useSessionStorage };

package/dist/hooks/session-storage/index.mjs

@@ -0,0 +1,46 @@
+"use client";
+import { useCallback, useMemo, useRef, useSyncExternalStore } from "react";
+//#region src/hooks/session-storage/index.ts
+const dispatchStorageEvent = (key, newValue) => window.dispatchEvent(new StorageEvent("storage", {
+	key,
+	newValue
+}));
+const getSessionStorageItem = (key) => window.sessionStorage.getItem(key);
+const sessionStorageSubscribe = (cb) => {
+	window.addEventListener("storage", cb);
+	return () => {
+		window.removeEventListener("storage", cb);
+	};
+};
+const useSessionStorage = (key, initialValue) => {
+	const initialValueRef = useRef(initialValue);
+	const getSnapshot = () => getSessionStorageItem(key);
+	const store = useSyncExternalStore(sessionStorageSubscribe, getSnapshot, () => null);
+	const current = useMemo(() => {
+		try {
+			if (store === null) return initialValueRef.current;
+			return JSON.parse(store);
+		} catch (e) {
+			console.error(e);
+			return initialValueRef.current;
+		}
+	}, [store]);
+	const handleRemove = useCallback(() => {
+		window.sessionStorage.removeItem(key);
+		dispatchStorageEvent(key, null);
+	}, [key]);
+	return [
+		current,
+		useCallback((value) => {
+			if (value === void 0 || value === null) handleRemove();
+			else {
+				const stringifiedValue = JSON.stringify(value);
+				window.sessionStorage.setItem(key, stringifiedValue);
+				dispatchStorageEvent(key, stringifiedValue);
+			}
+		}, [key, handleRemove]),
+		handleRemove
+	];
+};
+//#endregion
+export { useSessionStorage };

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

@@ -0,0 +1,15 @@
+//#region src/hooks/step/index.d.ts
+type Step = {
+  count: number;
+  next: () => void;
+  back: () => void;
+  isDisabledBack: boolean;
+  isDisabledNext: boolean;
+};
+type UseStep = (props: {
+  initialCount: number;
+  maxCount: number;
+}) => Step;
+declare const useStep: UseStep;
+//#endregion
+export { useStep };

package/dist/hooks/step/index.mjs

@@ -0,0 +1,39 @@
+"use client";
+import { useCallback, useEffect, useState } from "react";
+//#region src/hooks/step/index.ts
+const useStep = ({ initialCount, maxCount }) => {
+	const [count, setCount] = useState(initialCount);
+	const isDisabledBack = count === initialCount;
+	const isDisabledNext = count === maxCount;
+	const back = useCallback(() => {
+		setCount((prev) => {
+			if (prev === initialCount) return prev;
+			return prev - 1;
+		});
+	}, [initialCount]);
+	const next = useCallback(() => {
+		setCount((prev) => {
+			if (prev === maxCount) return prev;
+			return prev + 1;
+		});
+	}, [maxCount]);
+	useEffect(() => {
+		const listener = (e) => {
+			if (e.key === "ArrowLeft") back();
+			if (e.key === "ArrowRight") next();
+		};
+		window.addEventListener("keydown", listener);
+		return () => {
+			window.removeEventListener("keydown", listener);
+		};
+	}, [back, next]);
+	return {
+		count,
+		next,
+		back,
+		isDisabledBack,
+		isDisabledNext
+	};
+};
+//#endregion
+export { useStep };

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

@@ -0,0 +1,4 @@
+//#region src/hooks/timeout/index.d.ts
+declare const useTimeout: (callback: () => void, delay: number) => void;
+//#endregion
+export { useTimeout };

package/dist/hooks/timeout/index.mjs

@@ -0,0 +1,19 @@
+"use client";
+import { useEffect, useRef } from "react";
+//#region src/hooks/timeout/index.ts
+const useTimeout = (callback, delay) => {
+	const callbackRef = useRef(callback);
+	useEffect(() => {
+		callbackRef.current = callback;
+	});
+	useEffect(() => {
+		const timeoutId = window.setTimeout(() => {
+			callbackRef.current();
+		}, delay);
+		return () => {
+			window.clearTimeout(timeoutId);
+		};
+	}, [delay]);
+};
+//#endregion
+export { useTimeout };

package/dist/hooks/window-resize/index.d.mts

@@ -0,0 +1,11 @@
+//#region src/hooks/window-resize/index.d.ts
+type Size = {
+  width: number;
+  height: number;
+};
+type Options = {
+  enabled?: boolean;
+};
+declare const useWindowResize: (callback: (size: Size) => void, options?: Options) => void;
+//#endregion
+export { useWindowResize };

package/dist/hooks/window-resize/index.mjs

@@ -0,0 +1,21 @@
+"use client";
+import { useEffect } from "react";
+//#region src/hooks/window-resize/index.ts
+const useWindowResize = (callback, options = {}) => {
+	const { enabled = true } = options;
+	useEffect(() => {
+		if (!enabled) return void 0;
+		const handleResize = () => {
+			callback({
+				width: window.innerWidth,
+				height: window.innerHeight
+			});
+		};
+		window.addEventListener("resize", handleResize);
+		return () => {
+			window.removeEventListener("resize", handleResize);
+		};
+	}, [callback, enabled]);
+};
+//#endregion
+export { useWindowResize };

package/dist/hooks/window-size/index.d.mts

@@ -0,0 +1,8 @@
+//#region src/hooks/window-size/index.d.ts
+type Size = {
+  width: number;
+  height: number;
+};
+declare const useWindowSize: () => Size;
+//#endregion
+export { useWindowSize };

package/dist/hooks/window-size/index.mjs

@@ -0,0 +1,31 @@
+"use client";
+import { useSyncExternalStore } from "react";
+//#region src/hooks/window-size/index.ts
+let cachedSnapshot = {
+	width: 0,
+	height: 0
+};
+const getSnapshot = () => {
+	const w = window.innerWidth;
+	const h = window.innerHeight;
+	if (cachedSnapshot.width === w && cachedSnapshot.height === h) return cachedSnapshot;
+	cachedSnapshot = {
+		width: w,
+		height: h
+	};
+	return cachedSnapshot;
+};
+const SERVER_SNAPSHOT = {
+	width: 0,
+	height: 0
+};
+const getServerSnapshot = () => SERVER_SNAPSHOT;
+const subscribe = (callback) => {
+	window.addEventListener("resize", callback);
+	return () => {
+		window.removeEventListener("resize", callback);
+	};
+};
+const useWindowSize = () => useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
+//#endregion
+export { useWindowSize };

package/dist/hooks/writing-mode/index.d.mts

@@ -0,0 +1,6 @@
+import { RefObject } from "react";
+//#region src/hooks/writing-mode/index.d.ts
+type WritingMode = 'horizontal' | 'vertical';
+declare const useWritingMode: (ref: RefObject<Element | null>) => WritingMode;
+//#endregion
+export { WritingMode, useWritingMode };

package/dist/hooks/writing-mode/index.mjs

@@ -0,0 +1,24 @@
+"use client";
+import { useCallback, useSyncExternalStore } from "react";
+//#region src/hooks/writing-mode/index.ts
+const getServerSnapshot = () => "horizontal";
+const resolve = (value) => value.startsWith("vertical") || value.startsWith("sideways") ? "vertical" : "horizontal";
+const useWritingMode = (ref) => {
+	const subscribe = useCallback((onChange) => {
+		const el = ref.current;
+		if (!el) return () => {};
+		const observer = new ResizeObserver(onChange);
+		observer.observe(el);
+		return () => {
+			observer.disconnect();
+		};
+	}, [ref]);
+	const getSnapshot = useCallback(() => {
+		const el = ref.current;
+		if (!el) return "horizontal";
+		return resolve(getComputedStyle(el).writingMode);
+	}, [ref]);
+	return useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
+};
+//#endregion
+export { useWritingMode };

package/dist/i18n/context.d.mts

@@ -0,0 +1,9 @@
+import { Messages } from "./messages.mjs";
+import { FC, PropsWithChildren } from "react";
+//#region src/i18n/context.d.ts
+declare const useMessages: () => Messages;
+declare const MessagesProvider: FC<PropsWithChildren<{
+  messages?: Partial<Messages> | undefined;
+}>>;
+//#endregion
+export { MessagesProvider, useMessages };

package/dist/i18n/context.mjs

@@ -0,0 +1,19 @@
+"use client";
+import { ja } from "./ja.mjs";
+import { createContext, use, useMemo } from "react";
+import { jsx } from "react/jsx-runtime";
+//#region src/i18n/context.tsx
+const MessagesContext = createContext(void 0);
+const useMessages = () => use(MessagesContext) ?? ja;
+const MessagesProvider = ({ messages, children }) => {
+	const value = useMemo(() => messages === void 0 ? ja : {
+		...ja,
+		...messages
+	}, [messages]);
+	return /* @__PURE__ */ jsx(MessagesContext, {
+		value,
+		children
+	});
+};
+//#endregion
+export { MessagesProvider, useMessages };

package/dist/i18n/en.d.mts

@@ -0,0 +1,5 @@
+import { Messages } from "./messages.mjs";
+//#region src/i18n/en.d.ts
+declare const en: Messages;
+//#endregion
+export { en };

package/dist/i18n/en.mjs

@@ -0,0 +1,64 @@
+//#region src/i18n/en.ts
+const en = {
+	close: "Close",
+	required: "Required",
+	loading: "Loading",
+	avatar: "Avatar",
+	color: "Color",
+	alertSuccess: "Success",
+	alertInfo: "Information",
+	alertWarning: "Warning",
+	alertError: "Error",
+	toastRegion: "Notifications",
+	autocompletePlaceholder: "Type to filter",
+	autocompleteRemoveTag: "Remove tag",
+	autocompleteClear: "Clear all",
+	autocompleteEmpty: "No results",
+	fileFieldRemove: "Remove file",
+	fileFieldTrigger: "Select files",
+	numberFieldIncrement: "Increase",
+	numberFieldDecrement: "Decrease",
+	passwordShow: "Show password",
+	passwordHide: "Hide password",
+	listBoxPlaceholder: "Select an option",
+	breadcrumb: "Breadcrumb",
+	tabList: "Tabs",
+	paginationLabel: "Pagination",
+	paginationPrevious: "Previous",
+	paginationNext: "Next",
+	chat: "Chat",
+	scrollToLatest: "Scroll to latest message",
+	reasoning: "Reasoning",
+	reasoningStreaming: "Thinking…",
+	suggestions: "Suggestions",
+	send: "Send",
+	stop: "Stop",
+	toolInput: "Input",
+	toolOutput: "Output",
+	toolError: "The tool failed to run.",
+	toolDenied: "The tool run was not approved.",
+	responseCopied: "Copied",
+	responseCopyCode: "Copy code",
+	responseCopyLink: "Copy link",
+	responseCopyTable: "Copy table",
+	responseCopyTableAsCsv: "Copy table as CSV",
+	responseCopyTableAsMarkdown: "Copy table as Markdown",
+	responseCopyTableAsTsv: "Copy table as TSV",
+	responseDownloadDiagram: "Download diagram",
+	responseDownloadDiagramAsMmd: "Download diagram as MMD",
+	responseDownloadDiagramAsPng: "Download diagram as PNG",
+	responseDownloadDiagramAsSvg: "Download diagram as SVG",
+	responseDownloadFile: "Download file",
+	responseDownloadImage: "Download image",
+	responseDownloadTable: "Download table",
+	responseDownloadTableAsCsv: "Download table as CSV",
+	responseDownloadTableAsMarkdown: "Download table as Markdown",
+	responseExitFullscreen: "Exit fullscreen",
+	responseViewFullscreen: "View fullscreen",
+	responseImageNotAvailable: "Image not available",
+	responseOpenExternalLink: "Open external link?",
+	responseExternalLinkWarning: "You're about to visit an external website.",
+	responseOpenLink: "Open link"
+};
+//#endregion
+export { en };

package/dist/i18n/index.d.mts

@@ -0,0 +1,5 @@
+import { Messages } from "./messages.mjs";
+import { useMessages } from "./context.mjs";
+import { en } from "./en.mjs";
+import { ja } from "./ja.mjs";
+export { type Messages, en, ja, useMessages };

package/dist/i18n/index.mjs

@@ -0,0 +1,4 @@
+import { ja } from "./ja.mjs";
+import { useMessages } from "./context.mjs";
+import { en } from "./en.mjs";
+export { en, ja, useMessages };