fromsrc 0.0.0 → 0.0.1

package/dist/hooks/arrownav.js

@@ -0,0 +1,49 @@
+function getNextIndex(key, options) {
+  const { count, current, direction = "vertical", wrap = true, isDisabled } = options;
+  if (count === 0) return -1;
+  const isUp = key === "ArrowUp" || direction !== "vertical" && key === "ArrowLeft";
+  const isDown = key === "ArrowDown" || direction !== "vertical" && key === "ArrowRight";
+  const isHome = key === "Home";
+  const isEnd = key === "End";
+  if (!isUp && !isDown && !isHome && !isEnd) return current;
+  let next = current;
+  if (isHome) {
+    next = 0;
+    if (isDisabled) {
+      while (next < count && isDisabled(next)) next++;
+      if (next >= count) return current;
+    }
+    return next;
+  }
+  if (isEnd) {
+    next = count - 1;
+    if (isDisabled) {
+      while (next >= 0 && isDisabled(next)) next--;
+      if (next < 0) return current;
+    }
+    return next;
+  }
+  const step = isDown ? 1 : -1;
+  if (isDisabled) {
+    let attempts = 0;
+    do {
+      next += step;
+      if (wrap) {
+        next = (next + count) % count;
+      } else if (next < 0 || next >= count) {
+        return current;
+      }
+      attempts++;
+    } while (isDisabled(next) && attempts < count);
+    return attempts >= count ? current : next;
+  }
+  next += step;
+  if (wrap) {
+    next = (next + count) % count;
+  } else if (next < 0 || next >= count) {
+    return current;
+  }
+  return next;
+}
+
+export { getNextIndex };

package/dist/hooks/async.d.ts

@@ -0,0 +1,9 @@
+interface AsyncState<T, Args extends unknown[]> {
+    data: T | null;
+    error: Error | null;
+    loading: boolean;
+    execute: (...args: Args) => Promise<T | null>;
+}
+declare function useAsync<T, Args extends unknown[]>(fn: (...args: Args) => Promise<T>): AsyncState<T, Args>;
+
+export { type AsyncState, useAsync };

package/dist/hooks/async.js

@@ -0,0 +1,28 @@
+"use client";
+import { useState, useCallback } from 'react';
+
+function useAsync(fn) {
+  const [data, setData] = useState(null);
+  const [error, setError] = useState(null);
+  const [loading, setLoading] = useState(false);
+  const execute = useCallback(
+    async (...args) => {
+      setLoading(true);
+      setError(null);
+      try {
+        const result = await fn(...args);
+        setData(result);
+        setLoading(false);
+        return result;
+      } catch (e) {
+        setError(e instanceof Error ? e : new Error(String(e)));
+        setLoading(false);
+        return null;
+      }
+    },
+    [fn]
+  );
+  return { data, error, loading, execute };
+}
+
+export { useAsync };

package/dist/hooks/battery.d.ts

@@ -0,0 +1,8 @@
+interface BatteryState {
+    charging: boolean;
+    level: number;
+    supported: boolean;
+}
+declare function useBattery(): BatteryState;
+
+export { type BatteryState, useBattery };

package/dist/hooks/battery.js

@@ -0,0 +1,34 @@
+"use client";
+import { useState, useEffect } from 'react';
+
+function useBattery() {
+  const [state, setState] = useState({
+    charging: false,
+    level: 1,
+    supported: false
+  });
+  useEffect(() => {
+    const nav = navigator;
+    if (typeof navigator === "undefined" || typeof nav.getBattery !== "function") return;
+    let battery = null;
+    const update = () => {
+      if (!battery) return;
+      setState({ charging: battery.charging, level: battery.level, supported: true });
+    };
+    nav.getBattery().then((b) => {
+      battery = b;
+      update();
+      b.addEventListener("chargingchange", update);
+      b.addEventListener("levelchange", update);
+    });
+    return () => {
+      if (battery) {
+        battery.removeEventListener("chargingchange", update);
+        battery.removeEventListener("levelchange", update);
+      }
+    };
+  }, []);
+  return state;
+}
+
+export { useBattery };

package/dist/hooks/breakpoint.d.ts

@@ -0,0 +1,6 @@
+type Breakpoint = "sm" | "md" | "lg" | "xl" | "2xl";
+type BreakpointConfig = Record<Breakpoint, number>;
+declare function useBreakpoint(config?: Partial<BreakpointConfig>): Breakpoint;
+declare function useAboveBreakpoint(breakpoint: Breakpoint, config?: Partial<BreakpointConfig>): boolean;
+
+export { type Breakpoint, type BreakpointConfig, useAboveBreakpoint, useBreakpoint };

package/dist/hooks/breakpoint.js

@@ -0,0 +1,34 @@
+import { useState, useEffect } from 'react';
+
+const defaults = { sm: 640, md: 768, lg: 1024, xl: 1280, "2xl": 1536 };
+const ordered = ["2xl", "xl", "lg", "md", "sm"];
+function resolve(config) {
+  for (const bp of ordered) {
+    if (window.matchMedia(`(min-width: ${config[bp]}px)`).matches) return bp;
+  }
+  return "sm";
+}
+function useBreakpoint(config) {
+  const merged = { ...defaults, ...config };
+  const [breakpoint, setBreakpoint] = useState(
+    () => typeof window === "undefined" ? "lg" : resolve(merged)
+  );
+  useEffect(() => {
+    const queries = ordered.map((bp) => {
+      const mql = window.matchMedia(`(min-width: ${merged[bp]}px)`);
+      const handler = () => setBreakpoint(resolve(merged));
+      mql.addEventListener("change", handler);
+      return () => mql.removeEventListener("change", handler);
+    });
+    setBreakpoint(resolve(merged));
+    return () => queries.forEach((cleanup) => cleanup());
+  }, [merged.sm, merged.md, merged.lg, merged.xl, merged["2xl"]]);
+  return breakpoint;
+}
+function useAboveBreakpoint(breakpoint, config) {
+  const merged = { ...defaults, ...config };
+  const current = useBreakpoint(config);
+  return merged[current] >= merged[breakpoint];
+}
+
+export { useAboveBreakpoint, useBreakpoint };

package/dist/hooks/clickoutside.d.ts

@@ -0,0 +1,11 @@
+import { RefObject } from 'react';
+
+/**
+ * Triggers a callback when clicking outside the referenced element
+ * @param ref - Reference to the element to detect clicks outside of
+ * @param handler - Callback invoked when a click occurs outside the element
+ * @param enabled - Whether the listener is active (default: true)
+ */
+declare function useClickOutside<T extends HTMLElement>(ref: RefObject<T | null>, handler: () => void, enabled?: boolean): void;
+
+export { useClickOutside };

package/dist/hooks/clickoutside.js

@@ -0,0 +1,19 @@
+"use client";
+import { useCallback } from 'react';
+import { useEventListener } from './eventlistener';
+
+function useClickOutside(ref, handler, enabled = true) {
+  const handleClick = useCallback(
+    (e) => {
+      const target = e.target;
+      if (!(target instanceof Node)) return;
+      if (ref.current && !ref.current.contains(target)) {
+        handler();
+      }
+    },
+    [ref, handler]
+  );
+  useEventListener(typeof document !== "undefined" ? document : null, "click", handleClick, enabled);
+}
+
+export { useClickOutside };

package/dist/hooks/clipboard-paste.d.ts

@@ -0,0 +1,8 @@
+interface PasteData {
+    text: string | null;
+    files: File[];
+    timestamp: number;
+}
+declare function useClipboardPaste(): PasteData;
+
+export { type PasteData, useClipboardPaste };

package/dist/hooks/clipboard-paste.js

@@ -0,0 +1,18 @@
+"use client";
+import { useState, useEffect } from 'react';
+
+function useClipboardPaste() {
+  const [data, setData] = useState({ text: null, files: [], timestamp: 0 });
+  useEffect(() => {
+    function handler(e) {
+      const text = e.clipboardData?.getData("text/plain") ?? null;
+      const files = Array.from(e.clipboardData?.files ?? []);
+      setData({ text, files, timestamp: Date.now() });
+    }
+    document.addEventListener("paste", handler);
+    return () => document.removeEventListener("paste", handler);
+  }, []);
+  return data;
+}
+
+export { useClipboardPaste };

package/dist/hooks/clipboard.d.ts

@@ -0,0 +1,9 @@
+type ClipboardResult = {
+    copy: (text: string) => Promise<void>;
+    paste: () => Promise<string>;
+    copied: boolean;
+    supported: boolean;
+};
+declare function useClipboard(timeout?: number): ClipboardResult;
+
+export { type ClipboardResult, useClipboard };

package/dist/hooks/clipboard.js

@@ -0,0 +1,24 @@
+import { useState, useRef, useCallback, useEffect } from 'react';
+
+function useClipboard(timeout = 2e3) {
+  const [copied, setCopied] = useState(false);
+  const timer = useRef(null);
+  const supported = typeof navigator !== "undefined" && !!navigator.clipboard;
+  const copy = useCallback(async (text) => {
+    await navigator.clipboard.writeText(text);
+    setCopied(true);
+    if (timer.current) clearTimeout(timer.current);
+    timer.current = setTimeout(() => setCopied(false), timeout);
+  }, [timeout]);
+  const paste = useCallback(async () => {
+    return navigator.clipboard.readText();
+  }, []);
+  useEffect(() => {
+    return () => {
+      if (timer.current) clearTimeout(timer.current);
+    };
+  }, []);
+  return { copy, paste, copied, supported };
+}
+
+export { useClipboard };

package/dist/hooks/colorscheme.d.ts

@@ -0,0 +1,4 @@
+type ColorScheme = "light" | "dark";
+declare function useColorScheme(): ColorScheme;
+
+export { type ColorScheme, useColorScheme };

package/dist/hooks/colorscheme.js

@@ -0,0 +1,18 @@
+"use client";
+import { useState, useEffect } from 'react';
+
+function useColorScheme() {
+  const [scheme, setScheme] = useState("light");
+  useEffect(() => {
+    const mq = window.matchMedia("(prefers-color-scheme: dark)");
+    setScheme(mq.matches ? "dark" : "light");
+    function handler(e) {
+      setScheme(e.matches ? "dark" : "light");
+    }
+    mq.addEventListener("change", handler);
+    return () => mq.removeEventListener("change", handler);
+  }, []);
+  return scheme;
+}
+
+export { useColorScheme };

package/dist/hooks/copy.d.ts

@@ -0,0 +1,12 @@
+interface CopyResult {
+    copied: boolean;
+    copy: (text: string) => Promise<void>;
+}
+/**
+ * Hook for copying text to clipboard with automatic reset
+ * @param duration - Time in ms before copied state resets (default: 1500)
+ * @returns Object with copied state and copy function
+ */
+declare function useCopy(duration?: number): CopyResult;
+
+export { type CopyResult, useCopy };

package/dist/hooks/copy.js

@@ -0,0 +1,28 @@
+"use client";
+import { useState, useRef, useEffect, useCallback } from 'react';
+
+function useCopy(duration = 1500) {
+  const [copied, setCopied] = useState(false);
+  const timeoutRef = useRef(null);
+  useEffect(() => {
+    return () => {
+      if (timeoutRef.current) clearTimeout(timeoutRef.current);
+    };
+  }, []);
+  const copy = useCallback(
+    async (text) => {
+      try {
+        await navigator.clipboard.writeText(text);
+        setCopied(true);
+        if (timeoutRef.current) clearTimeout(timeoutRef.current);
+        timeoutRef.current = setTimeout(() => setCopied(false), duration);
+      } catch {
+        setCopied(false);
+      }
+    },
+    [duration]
+  );
+  return { copied, copy };
+}
+
+export { useCopy };

package/dist/hooks/countdown.d.ts

@@ -0,0 +1,10 @@
+interface CountdownResult {
+    remaining: number;
+    running: boolean;
+    start: () => void;
+    pause: () => void;
+    reset: () => void;
+}
+declare function useCountdown(seconds: number): CountdownResult;
+
+export { type CountdownResult, useCountdown };

package/dist/hooks/countdown.js

@@ -0,0 +1,41 @@
+"use client";
+import { useState, useRef, useCallback, useEffect } from 'react';
+
+function useCountdown(seconds) {
+  const [remaining, setRemaining] = useState(seconds);
+  const [running, setRunning] = useState(false);
+  const intervalRef = useRef(null);
+  const clear = useCallback(() => {
+    if (intervalRef.current) {
+      clearInterval(intervalRef.current);
+      intervalRef.current = null;
+    }
+  }, []);
+  const start = useCallback(() => {
+    clear();
+    setRunning(true);
+    intervalRef.current = setInterval(() => {
+      setRemaining((prev) => {
+        if (prev <= 1) {
+          clear();
+          setRunning(false);
+          return 0;
+        }
+        return prev - 1;
+      });
+    }, 1e3);
+  }, [clear]);
+  const pause = useCallback(() => {
+    clear();
+    setRunning(false);
+  }, [clear]);
+  const reset = useCallback(() => {
+    clear();
+    setRunning(false);
+    setRemaining(seconds);
+  }, [clear, seconds]);
+  useEffect(() => clear, [clear]);
+  return { remaining, running, start, pause, reset };
+}
+
+export { useCountdown };

package/dist/hooks/counter.d.ts

@@ -0,0 +1,10 @@
+interface CounterResult {
+    count: number;
+    increment: () => void;
+    decrement: () => void;
+    reset: () => void;
+    set: (value: number) => void;
+}
+declare function useCounter(initial?: number): CounterResult;
+
+export { type CounterResult, useCounter };

package/dist/hooks/counter.js

@@ -0,0 +1,12 @@
+"use client";
+import { useState, useCallback } from 'react';
+
+function useCounter(initial = 0) {
+  const [count, setCount] = useState(initial);
+  const increment = useCallback(() => setCount((c) => c + 1), []);
+  const decrement = useCallback(() => setCount((c) => c - 1), []);
+  const reset = useCallback(() => setCount(initial), [initial]);
+  return { count, increment, decrement, reset, set: setCount };
+}
+
+export { useCounter };

package/dist/hooks/debounce.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Debounce a value by delaying updates until after a specified delay.
+ * @param value - Value to debounce
+ * @param delay - Delay in milliseconds
+ * @returns Debounced value that updates after the delay
+ */
+declare function useDebounce<T>(value: T, delay: number): T;
+
+export { useDebounce };

package/dist/hooks/debounce.js

@@ -0,0 +1,16 @@
+"use client";
+import { useState, useEffect } from 'react';
+
+function useDebounce(value, delay) {
+  const [debounced, setDebounced] = useState(value);
+  useEffect(() => {
+    const timer = setTimeout(
+      () => setDebounced(value),
+      delay
+    );
+    return () => clearTimeout(timer);
+  }, [value, delay]);
+  return debounced;
+}
+
+export { useDebounce };

package/dist/hooks/documenttitle.d.ts

@@ -0,0 +1,3 @@
+declare function useDocumentTitle(title: string, restoreOnUnmount?: boolean): void;
+
+export { useDocumentTitle };

package/dist/hooks/documenttitle.js

@@ -0,0 +1,20 @@
+"use client";
+import { useRef, useEffect } from 'react';
+
+function useDocumentTitle(title, restoreOnUnmount = false) {
+  const previous = useRef("");
+  useEffect(() => {
+    previous.current = document.title;
+    document.title = title;
+  }, [title]);
+  useEffect(() => {
+    if (restoreOnUnmount) {
+      const saved = previous.current;
+      return () => {
+        document.title = saved;
+      };
+    }
+  }, [restoreOnUnmount]);
+}
+
+export { useDocumentTitle };

package/dist/hooks/documentvisibility.d.ts

@@ -0,0 +1,4 @@
+type VisibilityState = "visible" | "hidden";
+declare function useDocumentVisibility(): VisibilityState;
+
+export { type VisibilityState, useDocumentVisibility };

package/dist/hooks/documentvisibility.js

@@ -0,0 +1,19 @@
+"use client";
+import { useState, useEffect } from 'react';
+
+function tovisibility(value) {
+  return value === "hidden" ? "hidden" : "visible";
+}
+function useDocumentVisibility() {
+  const [state, setState] = useState("visible");
+  useEffect(() => {
+    function handler() {
+      setState(tovisibility(document.visibilityState));
+    }
+    document.addEventListener("visibilitychange", handler);
+    return () => document.removeEventListener("visibilitychange", handler);
+  }, []);
+  return state;
+}
+
+export { useDocumentVisibility };

package/dist/hooks/escapekey.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Triggers a callback when the Escape key is pressed
+ * @param handler - Callback invoked when Escape is pressed
+ * @param enabled - Whether the listener is active (default: true)
+ */
+declare function useEscapeKey(handler: () => void, enabled?: boolean): void;
+
+export { useEscapeKey };

package/dist/hooks/escapekey.js

@@ -0,0 +1,18 @@
+"use client";
+import { useCallback } from 'react';
+import { useEventListener } from './eventlistener';
+
+function useEscapeKey(handler, enabled = true) {
+  const handleKey = useCallback(
+    (e) => {
+      if (e.key === "Escape") {
+        e.preventDefault();
+        handler();
+      }
+    },
+    [handler]
+  );
+  useEventListener(typeof document !== "undefined" ? document : null, "keydown", handleKey, enabled);
+}
+
+export { useEscapeKey };

package/dist/hooks/eventlistener.d.ts

@@ -0,0 +1,13 @@
+type EventTarget = Window | Document | HTMLElement | null;
+type EventMap<T> = T extends Window ? WindowEventMap : T extends Document ? DocumentEventMap : T extends HTMLElement ? HTMLElementEventMap : never;
+/**
+ * Attaches an event listener to a target element with automatic cleanup
+ * @param target - The target to attach the listener to (window, document, or element)
+ * @param event - The event type to listen for
+ * @param handler - Callback invoked when the event fires
+ * @param enabled - Whether the listener is active (default: true)
+ * @param options - Optional addEventListener options
+ */
+declare function useEventListener<T extends EventTarget, K extends Extract<keyof EventMap<NonNullable<T>>, string>>(target: T, event: K, handler: (e: EventMap<NonNullable<T>>[K]) => void, enabled?: boolean, options?: AddEventListenerOptions): void;
+
+export { useEventListener };

package/dist/hooks/eventlistener.js

@@ -0,0 +1,15 @@
+"use client";
+import { useEffect } from 'react';
+
+function useEventListener(target, event, handler, enabled = true, options) {
+  useEffect(() => {
+    if (!enabled || !target) return;
+    const listener = handler;
+    target.addEventListener(event, listener, options);
+    return () => {
+      target.removeEventListener(event, listener, options);
+    };
+  }, [target, event, handler, enabled, options]);
+}
+
+export { useEventListener };

package/dist/hooks/eventsource.d.ts

@@ -0,0 +1,10 @@
+type EventSourceStatus = "connecting" | "open" | "closed";
+interface EventSourceResult {
+    status: EventSourceStatus;
+    lastEvent: string | null;
+    lastData: string | null;
+    close: () => void;
+}
+declare function useEventSource(url: string | null): EventSourceResult;
+
+export { type EventSourceResult, type EventSourceStatus, useEventSource };

package/dist/hooks/eventsource.js

@@ -0,0 +1,31 @@
+"use client";
+import { useState, useRef, useCallback, useEffect } from 'react';
+
+function useEventSource(url) {
+  const [status, setStatus] = useState("closed");
+  const [lastEvent, setLastEvent] = useState(null);
+  const [lastData, setLastData] = useState(null);
+  const sourceRef = useRef(null);
+  const close = useCallback(() => {
+    sourceRef.current?.close();
+    setStatus("closed");
+  }, []);
+  useEffect(() => {
+    if (!url) return;
+    setStatus("connecting");
+    const source = new EventSource(url);
+    sourceRef.current = source;
+    source.onopen = () => setStatus("open");
+    source.onerror = () => setStatus("closed");
+    source.onmessage = (e) => {
+      setLastEvent(e.type);
+      setLastData(e.data);
+    };
+    return () => {
+      source.close();
+    };
+  }, [url]);
+  return { status, lastEvent, lastData, close };
+}
+
+export { useEventSource };

package/dist/hooks/eyedropper.d.ts

@@ -0,0 +1,8 @@
+interface EyeDropperResult {
+    color: string | null;
+    supported: boolean;
+    pick: () => Promise<string | null>;
+}
+declare function useEyeDropper(): EyeDropperResult;
+
+export { type EyeDropperResult, useEyeDropper };

package/dist/hooks/eyedropper.js

@@ -0,0 +1,23 @@
+"use client";
+import { useState, useCallback } from 'react';
+
+function useEyeDropper() {
+  const [color, setColor] = useState(null);
+  const supported = typeof window !== "undefined" && "EyeDropper" in window;
+  const pick = useCallback(async () => {
+    if (!supported) return null;
+    try {
+      const Dropper = window.EyeDropper;
+      if (!Dropper) return null;
+      const dropper = new Dropper();
+      const result = await dropper.open();
+      setColor(result.sRGBHex);
+      return result.sRGBHex;
+    } catch {
+      return null;
+    }
+  }, [supported]);
+  return { color, supported, pick };
+}
+
+export { useEyeDropper };

package/dist/hooks/favicon.d.ts

@@ -0,0 +1,3 @@
+declare function useFavicon(href: string): void;
+
+export { useFavicon };

package/dist/hooks/favicon.js

@@ -0,0 +1,14 @@
+"use client";
+import { useEffect } from 'react';
+
+function useFavicon(href) {
+  useEffect(() => {
+    const link = document.querySelector("link[rel*='icon']") || document.createElement("link");
+    link.type = "image/x-icon";
+    link.rel = "shortcut icon";
+    link.href = href;
+    document.head.appendChild(link);
+  }, [href]);
+}
+
+export { useFavicon };