fromsrc 0.0.2 → 0.0.21

package/dist/hooks/clipboard.d.ts

@@ -1,9 +1,9 @@
-type ClipboardResult = {
+interface 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

@@ -4,21 +4,27 @@ 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 };
+  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(() => navigator.clipboard.readText(), []);
+  useEffect(
+    () => () => {
+      if (timer.current) {
+        clearTimeout(timer.current);
+      }
+    },
+    []
+  );
+  return { copied, copy, paste, supported };
 }
 
 export { useClipboard };

package/dist/hooks/copy.js

@@ -4,17 +4,22 @@ 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);
-    };
-  }, []);
+  useEffect(
+    () => () => {
+      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);
+        if (timeoutRef.current) {
+          clearTimeout(timeoutRef.current);
+        }
         timeoutRef.current = setTimeout(() => setCopied(false), duration);
       } catch {
         setCopied(false);

package/dist/hooks/countdown.js

@@ -35,7 +35,7 @@ function useCountdown(seconds) {
     setRemaining(seconds);
   }, [clear, seconds]);
   useEffect(() => clear, [clear]);
-  return { remaining, running, start, pause, reset };
+  return { pause, remaining, reset, running, start };
 }
 
 export { useCountdown };

package/dist/hooks/counter.js

@@ -6,7 +6,7 @@ function useCounter(initial = 0) {
   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 };
+  return { count, decrement, increment, reset, set: setCount };
 }
 
 export { useCounter };

package/dist/hooks/escapekey.js

@@ -12,7 +12,12 @@ function useEscapeKey(handler, enabled = true) {
     },
     [handler]
   );
-  useEventListener(typeof document !== "undefined" ? document : null, "keydown", handleKey, enabled);
+  useEventListener(
+    typeof document !== "undefined" ? document : null,
+    "keydown",
+    handleKey,
+    enabled
+  );
 }
 
 export { useEscapeKey };

package/dist/hooks/eventlistener.js

@@ -3,7 +3,9 @@ import { useEffect } from 'react';
 
 function useEventListener(target, event, handler, enabled = true, options) {
   useEffect(() => {
-    if (!enabled || !target) return;
+    if (!enabled || !target) {
+      return;
+    }
     const listener = handler;
     target.addEventListener(event, listener, options);
     return () => {

package/dist/hooks/eventsource.js

@@ -11,7 +11,9 @@ function useEventSource(url) {
     setStatus("closed");
   }, []);
   useEffect(() => {
-    if (!url) return;
+    if (!url) {
+      return;
+    }
     setStatus("connecting");
     const source = new EventSource(url);
     sourceRef.current = source;
@@ -25,7 +27,7 @@ function useEventSource(url) {
       source.close();
     };
   }, [url]);
-  return { status, lastEvent, lastData, close };
+  return { close, lastData, lastEvent, status };
 }
 
 export { useEventSource };

package/dist/hooks/eyedropper.js

@@ -5,10 +5,14 @@ function useEyeDropper() {
   const [color, setColor] = useState(null);
   const supported = typeof window !== "undefined" && "EyeDropper" in window;
   const pick = useCallback(async () => {
-    if (!supported) return null;
+    if (!supported) {
+      return null;
+    }
     try {
       const Dropper = window.EyeDropper;
-      if (!Dropper) return null;
+      if (!Dropper) {
+        return null;
+      }
       const dropper = new Dropper();
       const result = await dropper.open();
       setColor(result.sRGBHex);
@@ -17,7 +21,7 @@ function useEyeDropper() {
       return null;
     }
   }, [supported]);
-  return { color, supported, pick };
+  return { color, pick, supported };
 }
 
 export { useEyeDropper };

package/dist/hooks/favicon.js

@@ -7,7 +7,7 @@ function useFavicon(href) {
     link.type = "image/x-icon";
     link.rel = "shortcut icon";
     link.href = href;
-    document.head.appendChild(link);
+    document.head.append(link);
   }, [href]);
 }
 

package/dist/hooks/fetch.js

@@ -8,16 +8,24 @@ function useFetch(url, options) {
     loading: !!url
   });
   useEffect(() => {
-    if (!url) return;
+    if (!url) {
+      return;
+    }
     let cancelled = false;
     setState({ data: null, error: null, loading: true });
     fetch(url, options).then((res) => {
-      if (!res.ok) throw new Error(res.statusText);
+      if (!res.ok) {
+        throw new Error(res.statusText);
+      }
       return res.json();
     }).then((data) => {
-      if (!cancelled) setState({ data, error: null, loading: false });
+      if (!cancelled) {
+        setState({ data, error: null, loading: false });
+      }
     }).catch((error) => {
-      if (!cancelled) setState({ data: null, error, loading: false });
+      if (!cancelled) {
+        setState({ data: null, error, loading: false });
+      }
     });
     return () => {
       cancelled = true;

package/dist/hooks/focustrap.js

@@ -6,8 +6,10 @@ function useFocusTrap(ref, options) {
   const { enabled, onEscape, autoFocus = true, restoreFocus = true } = options;
   const previousFocus = useRef(null);
   const getFocusableElements = useCallback(() => {
-    if (!ref.current) return [];
-    return Array.from(ref.current.querySelectorAll(FOCUSABLE_SELECTOR));
+    if (!ref.current) {
+      return [];
+    }
+    return [...ref.current.querySelectorAll(FOCUSABLE_SELECTOR)];
   }, [ref]);
   const handleKeyDown = useCallback(
     (e) => {
@@ -15,11 +17,15 @@ function useFocusTrap(ref, options) {
         onEscape();
         return;
       }
-      if (e.key !== "Tab") return;
+      if (e.key !== "Tab") {
+        return;
+      }
       const focusable = getFocusableElements();
-      if (focusable.length === 0) return;
+      if (focusable.length === 0) {
+        return;
+      }
       const first = focusable[0];
-      const last = focusable[focusable.length - 1];
+      const last = focusable.at(-1);
       if (e.shiftKey && document.activeElement === first) {
         e.preventDefault();
         last?.focus();
@@ -31,7 +37,9 @@ function useFocusTrap(ref, options) {
     [onEscape, getFocusableElements]
   );
   useEffect(() => {
-    if (!enabled) return;
+    if (!enabled) {
+      return;
+    }
     previousFocus.current = document.activeElement instanceof HTMLElement ? document.activeElement : null;
     document.addEventListener("keydown", handleKeyDown);
     return () => {
@@ -42,12 +50,16 @@ function useFocusTrap(ref, options) {
     };
   }, [enabled, handleKeyDown, restoreFocus]);
   useEffect(() => {
-    if (!enabled || !autoFocus) return;
+    if (!enabled || !autoFocus) {
+      return;
+    }
     const focusable = getFocusableElements();
     focusable[0]?.focus();
   }, [enabled, autoFocus, getFocusableElements]);
   useEffect(() => {
-    if (!enabled) return;
+    if (!enabled) {
+      return;
+    }
     const handleFocusIn = (e) => {
       if (!(e.target instanceof Node) || !ref.current?.contains(e.target)) {
         const focusable = getFocusableElements();

package/dist/hooks/focuswithin.js

@@ -6,10 +6,14 @@ function useFocusWithin() {
   const [focused, setFocused] = useState(false);
   useEffect(() => {
     const el = ref.current;
-    if (!el) return;
+    if (!el) {
+      return;
+    }
     const onFocusIn = () => setFocused(true);
     const onFocusOut = (e) => {
-      if (!(e.relatedTarget instanceof Node) || !el.contains(e.relatedTarget)) setFocused(false);
+      if (!(e.relatedTarget instanceof Node) || !el.contains(e.relatedTarget)) {
+        setFocused(false);
+      }
     };
     el.addEventListener("focusin", onFocusIn);
     el.addEventListener("focusout", onFocusOut);

package/dist/hooks/form.d.ts

@@ -1,8 +1,8 @@
-type changeevent = {
+interface changeevent {
     target: {
         value: unknown;
     };
-};
+}
 interface FormState<T extends Record<string, unknown>> {
     values: T;
     errors: Partial<Record<keyof T, string>>;

package/dist/hooks/form.js

@@ -14,7 +14,9 @@ function useForm(initial, validate) {
     (field, value) => {
       setValues((prev) => {
         const next = update(prev, field, value);
-        if (validate) setErrors(validate(next));
+        if (validate) {
+          setErrors(validate(next));
+        }
         return next;
       });
     },
@@ -36,7 +38,18 @@ function useForm(initial, validate) {
     (field) => () => setTouched((prev) => ({ ...prev, [field]: true })),
     []
   );
-  return { values, errors, touched, dirty, valid, set, setError, reset, handleChange, handleBlur };
+  return {
+    dirty,
+    errors,
+    handleBlur,
+    handleChange,
+    reset,
+    set,
+    setError,
+    touched,
+    valid,
+    values
+  };
 }
 
 export { useForm };

package/dist/hooks/fullscreen.js

@@ -28,7 +28,7 @@ function useFullscreen() {
       await ref.current.requestFullscreen();
     }
   }, []);
-  return { isFullscreen, enter, exit, toggle, ref };
+  return { enter, exit, isFullscreen, ref, toggle };
 }
 
 export { useFullscreen };

package/dist/hooks/geolocation.js

@@ -3,27 +3,27 @@ import { useState, useCallback, useEffect } from 'react';
 
 function useGeolocation(watch = false) {
   const [pos, setPos] = useState({
-    latitude: null,
-    longitude: null,
     accuracy: null,
+    error: null,
+    latitude: null,
     loading: true,
-    error: null
+    longitude: null
   });
   const onSuccess = useCallback((p) => {
     setPos({
-      latitude: p.coords.latitude,
-      longitude: p.coords.longitude,
       accuracy: p.coords.accuracy,
+      error: null,
+      latitude: p.coords.latitude,
       loading: false,
-      error: null
+      longitude: p.coords.longitude
     });
   }, []);
   const onError = useCallback((e) => {
-    setPos((prev) => ({ ...prev, loading: false, error: e.message }));
+    setPos((prev) => ({ ...prev, error: e.message, loading: false }));
   }, []);
   useEffect(() => {
     if (typeof navigator === "undefined" || !navigator.geolocation) {
-      setPos((prev) => ({ ...prev, loading: false, error: "unsupported" }));
+      setPos((prev) => ({ ...prev, error: "unsupported", loading: false }));
       return;
     }
     navigator.geolocation.getCurrentPosition(onSuccess, onError);

package/dist/hooks/hotkeys.js

@@ -2,11 +2,21 @@
 import { useRef, useEffect } from 'react';
 
 function matches(e, binding) {
-  if (e.key.toLowerCase() !== binding.key.toLowerCase()) return false;
-  if (binding.ctrl && !e.ctrlKey) return false;
-  if (binding.meta && !e.metaKey) return false;
-  if (binding.shift && !e.shiftKey) return false;
-  if (binding.alt && !e.altKey) return false;
+  if (e.key.toLowerCase() !== binding.key.toLowerCase()) {
+    return false;
+  }
+  if (binding.ctrl && !e.ctrlKey) {
+    return false;
+  }
+  if (binding.meta && !e.metaKey) {
+    return false;
+  }
+  if (binding.shift && !e.shiftKey) {
+    return false;
+  }
+  if (binding.alt && !e.altKey) {
+    return false;
+  }
   return true;
 }
 function useHotkeys(bindings) {
@@ -14,8 +24,10 @@ function useHotkeys(bindings) {
   ref.current = bindings;
   useEffect(() => {
     function handle(e) {
-      if (!(e.target instanceof HTMLElement)) return;
-      const target = e.target;
+      if (!(e.target instanceof HTMLElement)) {
+        return;
+      }
+      const { target } = e;
       if (target.tagName === "INPUT" || target.tagName === "TEXTAREA" || target.isContentEditable) {
         return;
       }

package/dist/hooks/hover.d.ts

@@ -1,3 +1,6 @@
-declare function useHover<T extends HTMLElement>(): [React.RefObject<T | null>, boolean];
+declare function useHover<T extends HTMLElement>(): [
+    React.RefObject<T | null>,
+    boolean
+];
 
 export { useHover };

package/dist/hooks/hover.js

@@ -6,7 +6,9 @@ function useHover() {
   const [hovered, setHovered] = useState(false);
   useEffect(() => {
     const el = ref.current;
-    if (!el) return;
+    if (!el) {
+      return;
+    }
     const enter = () => setHovered(true);
     const leave = () => setHovered(false);
     el.addEventListener("mouseenter", enter);

package/dist/hooks/idle.js

@@ -7,10 +7,18 @@ function useIdle(timeout = 6e4) {
   useEffect(() => {
     function reset() {
       setIdle(false);
-      if (timer.current) clearTimeout(timer.current);
+      if (timer.current) {
+        clearTimeout(timer.current);
+      }
       timer.current = setTimeout(() => setIdle(true), timeout);
     }
-    const events = ["mousemove", "keydown", "scroll", "touchstart", "click"];
+    const events = [
+      "mousemove",
+      "keydown",
+      "scroll",
+      "touchstart",
+      "click"
+    ];
     for (const event of events) {
       window.addEventListener(event, reset, { passive: true });
     }
@@ -19,7 +27,9 @@ function useIdle(timeout = 6e4) {
       for (const event of events) {
         window.removeEventListener(event, reset);
       }
-      if (timer.current) clearTimeout(timer.current);
+      if (timer.current) {
+        clearTimeout(timer.current);
+      }
     };
   }, [timeout]);
   return idle;

package/dist/hooks/infinitescroll.js

@@ -7,7 +7,9 @@ function useInfiniteScroll(onLoadMore, threshold = 200) {
   const [done, setDone] = useState(false);
   const loadingRef = useRef(false);
   const handleScroll = useCallback(() => {
-    if (loadingRef.current || done) return;
+    if (loadingRef.current || done) {
+      return;
+    }
     const el = ref.current;
     const target = el || document.documentElement;
     const scrollBottom = target.scrollHeight - target.scrollTop - target.clientHeight;
@@ -25,7 +27,7 @@ function useInfiniteScroll(onLoadMore, threshold = 200) {
     el.addEventListener("scroll", handleScroll, { passive: true });
     return () => el.removeEventListener("scroll", handleScroll);
   }, [handleScroll]);
-  return { ref, loading, done, setDone };
+  return { done, loading, ref, setDone };
 }
 
 export { useInfiniteScroll };

package/dist/hooks/interval.js

@@ -7,7 +7,9 @@ function useInterval(callback, delay) {
     savedCallback.current = callback;
   }, [callback]);
   useEffect(() => {
-    if (delay === null) return;
+    if (delay === null) {
+      return;
+    }
     const id = setInterval(() => savedCallback.current(), delay);
     return () => clearInterval(id);
   }, [delay]);

package/dist/hooks/inview.js

@@ -7,17 +7,21 @@ function useInView(options = {}) {
   const [inView, setInView] = useState(false);
   useEffect(() => {
     const element = ref.current;
-    if (!element) return;
+    if (!element) {
+      return;
+    }
     const observer = new IntersectionObserver(
       ([entry]) => {
-        if (!entry) return;
+        if (!entry) {
+          return;
+        }
         const visible = entry.isIntersecting;
         setInView(visible);
         if (visible && once) {
           observer.disconnect();
         }
       },
-      { threshold, rootMargin }
+      { rootMargin, threshold }
     );
     observer.observe(element);
     return () => observer.disconnect();

package/dist/hooks/keyboard.js

@@ -31,20 +31,30 @@ function useKeyboardNav(docs, basePath = "/docs") {
   const router = useRouter();
   useEffect(() => {
     const sorted = sortDocs(docs);
-    const paths = sorted.map((d) => d.slug ? `${basePath}/${d.slug}` : basePath);
+    const paths = sorted.map(
+      (d) => d.slug ? `${basePath}/${d.slug}` : basePath
+    );
     const current = paths.indexOf(pathname);
     const handleKeyDown = (e) => {
-      if (e.target instanceof HTMLInputElement || e.target instanceof HTMLTextAreaElement) return;
-      if (e.metaKey || e.ctrlKey || e.altKey || e.shiftKey) return;
+      if (e.target instanceof HTMLInputElement || e.target instanceof HTMLTextAreaElement) {
+        return;
+      }
+      if (e.metaKey || e.ctrlKey || e.altKey || e.shiftKey) {
+        return;
+      }
       if (e.key === "ArrowRight" && current < paths.length - 1) {
         e.preventDefault();
         const next = paths[current + 1];
-        if (next) router.push(next);
+        if (next) {
+          router.push(next);
+        }
       }
       if (e.key === "ArrowLeft" && current > 0) {
         e.preventDefault();
         const prev = paths[current - 1];
-        if (prev) router.push(prev);
+        if (prev) {
+          router.push(prev);
+        }
       }
     };
     window.addEventListener("keydown", handleKeyDown);
@@ -52,8 +62,12 @@ function useKeyboardNav(docs, basePath = "/docs") {
   }, [docs, pathname, router, basePath]);
 }
 function editable(target) {
-  if (!(target instanceof HTMLElement)) return false;
-  if (target.tagName === "INPUT" || target.tagName === "TEXTAREA") return true;
+  if (!(target instanceof HTMLElement)) {
+    return false;
+  }
+  if (target.tagName === "INPUT" || target.tagName === "TEXTAREA") {
+    return true;
+  }
   return target.isContentEditable;
 }
 function useKeyboardShortcut(key, callback, options = {}) {
@@ -63,12 +77,22 @@ function useKeyboardShortcut(key, callback, options = {}) {
   optionsRef.current = options;
   useEffect(() => {
     function handler(e) {
-      if (editable(e.target)) return;
+      if (editable(e.target)) {
+        return;
+      }
       const opts = optionsRef.current;
-      if (opts.ctrl && !e.ctrlKey) return;
-      if (opts.meta && !e.metaKey) return;
-      if (opts.shift && !e.shiftKey) return;
-      if (e.key.toLowerCase() !== key.toLowerCase()) return;
+      if (opts.ctrl && !e.ctrlKey) {
+        return;
+      }
+      if (opts.meta && !e.metaKey) {
+        return;
+      }
+      if (opts.shift && !e.shiftKey) {
+        return;
+      }
+      if (e.key.toLowerCase() !== key.toLowerCase()) {
+        return;
+      }
       if (opts.preventDefault !== false) {
         e.preventDefault();
       }

package/dist/hooks/keypress.js

@@ -5,10 +5,14 @@ function useKeyPress(targetKey) {
   const [pressed, setPressed] = useState(false);
   useEffect(() => {
     function down(e) {
-      if (e.key === targetKey) setPressed(true);
+      if (e.key === targetKey) {
+        setPressed(true);
+      }
     }
     function up(e) {
-      if (e.key === targetKey) setPressed(false);
+      if (e.key === targetKey) {
+        setPressed(false);
+      }
     }
     window.addEventListener("keydown", down);
     window.addEventListener("keyup", up);

package/dist/hooks/list.js

@@ -22,7 +22,17 @@ function useList(initial = []) {
   const sort = useCallback((fn) => {
     setItems((prev) => [...prev].sort(fn));
   }, []);
-  return { items, set: setItems, push, removeAt, updateAt, insertAt, clear, filter, sort };
+  return {
+    clear,
+    filter,
+    insertAt,
+    items,
+    push,
+    removeAt,
+    set: setItems,
+    sort,
+    updateAt
+  };
 }
 
 export { useList };