@forgedevstack/bear 1.0.2 → 1.0.4-alpha

package/dist/hooks/useBounce/useBounce.js

@@ -0,0 +1,36 @@
+import { useRef as d, useState as m, useCallback as i, useEffect as g } from "react";
+function y(h = {}) {
+  const {
+    height: C = 20,
+    duration: n = 600,
+    count: o = 0,
+    delay: a = 0,
+    autoStart: l = !0
+  } = h, b = d(null), [e, u] = m(!1), [p, f] = m(0), s = i(() => {
+    f(0), u(!0);
+  }, []), r = i(() => {
+    u(!1);
+  }, []), v = i(() => {
+    u((t) => !t);
+  }, []);
+  g(() => {
+    if (l) {
+      const t = setTimeout(s, a);
+      return () => clearTimeout(t);
+    }
+  }, [l, a, s]), g(() => {
+    if (!e || o === 0) return;
+    const t = setInterval(() => {
+      f((c) => c + 1 >= o ? (r(), c) : c + 1);
+    }, n);
+    return () => clearInterval(t);
+  }, [e, o, n, r]);
+  const I = e ? {
+    animation: `bounce-custom ${n}ms ease-in-out infinite`,
+    "--bounce-height": `-${C}px`
+  } : {};
+  return { ref: b, style: I, isActive: e, start: s, stop: r, toggle: v };
+}
+export {
+  y as useBounce
+};

package/dist/hooks/useBounce/useBounce.types.d.ts

@@ -0,0 +1,27 @@
+import { RefObject, CSSProperties } from 'react';
+export interface UseBounceOptions {
+    /** Bounce height in pixels */
+    height?: number;
+    /** Duration of one bounce cycle (in ms) */
+    duration?: number;
+    /** Number of bounces (0 for infinite) */
+    count?: number;
+    /** Delay before starting (in ms) */
+    delay?: number;
+    /** Start animation on mount */
+    autoStart?: boolean;
+}
+export interface UseBounceReturn<T extends HTMLElement> {
+    /** Ref to attach to the element */
+    ref: RefObject<T>;
+    /** Style object to apply */
+    style: CSSProperties;
+    /** Whether bouncing is active */
+    isActive: boolean;
+    /** Start bouncing */
+    start: () => void;
+    /** Stop bouncing */
+    stop: () => void;
+    /** Toggle bouncing */
+    toggle: () => void;
+}

package/dist/hooks/useClickOutside/index.d.ts

@@ -0,0 +1,2 @@
+export { useClickOutside, useClickOutsideMultiple } from './useClickOutside';
+export type { UseClickOutsideOptions, UseClickOutsideRef } from './useClickOutside.types';

package/dist/hooks/useClickOutside/useClickOutside.d.ts

@@ -0,0 +1,22 @@
+import { RefObject } from 'react';
+import { UseClickOutsideOptions } from './useClickOutside.types';
+/**
+ * useClickOutside - Detect clicks outside an element
+ *
+ * @example
+ * ```tsx
+ * const ref = useRef<HTMLDivElement>(null);
+ *
+ * useClickOutside(ref, () => {
+ *   closeDropdown();
+ * });
+ *
+ * return <div ref={ref}>Dropdown content</div>;
+ * ```
+ */
+export declare const useClickOutside: <T extends HTMLElement>(ref: RefObject<T>, callback: (event: MouseEvent | TouchEvent) => void, options?: UseClickOutsideOptions) => void;
+/**
+ * useClickOutsideMultiple - Detect clicks outside multiple elements
+ */
+export declare const useClickOutsideMultiple: <T extends HTMLElement>(refs: RefObject<T>[], callback: (event: MouseEvent | TouchEvent) => void, options?: UseClickOutsideOptions) => void;
+export default useClickOutside;

package/dist/hooks/useClickOutside/useClickOutside.types.d.ts

@@ -0,0 +1,10 @@
+import { RefObject } from 'react';
+export interface UseClickOutsideOptions {
+    /** Event type to listen for */
+    events?: ('mousedown' | 'mouseup' | 'touchstart' | 'touchend')[];
+    /** Ignore elements with these selectors */
+    ignoreSelectors?: string[];
+    /** Whether the hook is enabled */
+    enabled?: boolean;
+}
+export type UseClickOutsideRef<T extends HTMLElement> = RefObject<T>;

package/dist/hooks/useClipboard/index.d.ts

@@ -0,0 +1,2 @@
+export { useClipboard } from './useClipboard';
+export type { UseClipboardOptions, UseClipboardReturn } from './useClipboard.types';

package/dist/hooks/useClipboard/useClipboard.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("react"),T=2e3,C=(p={})=>{const{timeout:u=T,onSuccess:r,onError:t}=p,[b,a]=e.useState(!1),[d,f]=e.useState(null),[y,s]=e.useState(null),o=e.useRef(null),l=e.useCallback(()=>{a(!1),s(null),o.current&&(clearTimeout(o.current),o.current=null)},[]);return{copy:e.useCallback(async n=>{l();try{if(!(navigator!=null&&navigator.clipboard))throw new Error("Clipboard API not available");return await navigator.clipboard.writeText(n),f(n),a(!0),r==null||r(n),o.current=setTimeout(()=>{a(!1)},u),!0}catch(c){const i=c instanceof Error?c:new Error("Failed to copy");return s(i),t==null||t(i),!1}},[u,r,t,l]),copied:b,value:d,reset:l,error:y}};exports.useClipboard=C;

package/dist/hooks/useClipboard/useClipboard.d.ts

@@ -0,0 +1,15 @@
+import { UseClipboardOptions, UseClipboardReturn } from './useClipboard.types';
+/**
+ * useClipboard - Copy text to clipboard with status tracking
+ *
+ * @example
+ * ```tsx
+ * const { copy, copied } = useClipboard();
+ *
+ * <Button onClick={() => copy('Hello!')}>
+ *   {copied ? 'Copied!' : 'Copy'}
+ * </Button>
+ * ```
+ */
+export declare const useClipboard: (options?: UseClipboardOptions) => UseClipboardReturn;
+export default useClipboard;

package/dist/hooks/useClipboard/useClipboard.js

@@ -0,0 +1,22 @@
+import { useState as l, useRef as w, useCallback as p } from "react";
+const y = 2e3, C = (f = {}) => {
+  const { timeout: c = y, onSuccess: r, onError: e } = f, [d, o] = l(!1), [b, m] = l(null), [T, s] = l(null), t = w(null), n = p(() => {
+    o(!1), s(null), t.current && (clearTimeout(t.current), t.current = null);
+  }, []);
+  return { copy: p(async (a) => {
+    n();
+    try {
+      if (!(navigator != null && navigator.clipboard))
+        throw new Error("Clipboard API not available");
+      return await navigator.clipboard.writeText(a), m(a), o(!0), r == null || r(a), t.current = setTimeout(() => {
+        o(!1);
+      }, c), !0;
+    } catch (u) {
+      const i = u instanceof Error ? u : new Error("Failed to copy");
+      return s(i), e == null || e(i), !1;
+    }
+  }, [c, r, e, n]), copied: d, value: b, reset: n, error: T };
+};
+export {
+  C as useClipboard
+};

package/dist/hooks/useClipboard/useClipboard.types.d.ts

@@ -0,0 +1,20 @@
+export interface UseClipboardOptions {
+    /** Timeout in ms before resetting copied state */
+    timeout?: number;
+    /** Callback when copy succeeds */
+    onSuccess?: (value: string) => void;
+    /** Callback when copy fails */
+    onError?: (error: Error) => void;
+}
+export interface UseClipboardReturn {
+    /** Copy text to clipboard */
+    copy: (value: string) => Promise<boolean>;
+    /** Whether text was recently copied */
+    copied: boolean;
+    /** Last copied value */
+    value: string | null;
+    /** Reset copied state */
+    reset: () => void;
+    /** Error if copy failed */
+    error: Error | null;
+}

package/dist/hooks/useDebounce/index.d.ts

@@ -0,0 +1,2 @@
+export { useDebounce, useDebouncedCallback } from './useDebounce';
+export type { UseDebounceOptions, UseDebouncedCallbackReturn } from './useDebounce.types';

package/dist/hooks/useDebounce/useDebounce.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("react"),R=300;function k(n,c=R){const[a,i]=e.useState(n);return e.useEffect(()=>{const l=setTimeout(()=>{i(n)},c);return()=>{clearTimeout(l)}},[n,c]),a}function g(n,c=R,a={}){const{leading:i=!1,trailing:l=!0,maxWait:f}=a,s=e.useRef(n),t=e.useRef(null),o=e.useRef(null),u=e.useRef(null),b=e.useRef(null);e.useEffect(()=>{s.current=n},[n]);const r=e.useCallback(()=>{t.current&&(clearTimeout(t.current),t.current=null),o.current&&(clearTimeout(o.current),o.current=null),u.current=null,b.current=null},[]),T=e.useCallback(()=>{u.current&&(s.current(...u.current),r())},[r]),d=e.useCallback(()=>t.current!==null,[]),C=e.useCallback((...m)=>{u.current=m;const D=Date.now();i&&!t.current&&s.current(...m),t.current&&clearTimeout(t.current),l&&(t.current=setTimeout(()=>{u.current&&l&&s.current(...u.current),r()},c)),f!==void 0&&!o.current&&(b.current=D,o.current=setTimeout(()=>{u.current&&s.current(...u.current),r()},f))},[c,i,l,f,r]);return e.useEffect(()=>()=>{r()},[r]),{callback:C,cancel:r,flush:T,isPending:d}}exports.useDebounce=k;exports.useDebouncedCallback=g;

package/dist/hooks/useDebounce/useDebounce.d.ts

@@ -0,0 +1,32 @@
+import { UseDebounceOptions } from './useDebounce.types';
+/**
+ * useDebounce - Debounce a value
+ *
+ * @example
+ * ```tsx
+ * const [search, setSearch] = useState('');
+ * const debouncedSearch = useDebounce(search, 500);
+ *
+ * useEffect(() => {
+ *   fetchResults(debouncedSearch);
+ * }, [debouncedSearch]);
+ * ```
+ */
+export declare function useDebounce<T>(value: T, delay?: number): T;
+/**
+ * useDebouncedCallback - Debounce a callback function
+ *
+ * @example
+ * ```tsx
+ * const debouncedSave = useDebouncedCallback((value) => {
+ *   saveToServer(value);
+ * }, 500);
+ * ```
+ */
+export declare function useDebouncedCallback<T extends (...args: unknown[]) => unknown>(callback: T, delay?: number, options?: UseDebounceOptions): {
+    callback: (...args: Parameters<T>) => void;
+    cancel: () => void;
+    flush: () => void;
+    isPending: () => boolean;
+};
+export default useDebounce;

package/dist/hooks/useDebounce/useDebounce.js

@@ -0,0 +1,39 @@
+import { useState as x, useEffect as T, useRef as i, useCallback as f } from "react";
+const D = 300;
+function E(n, u = D) {
+  const [a, s] = x(n);
+  return T(() => {
+    const c = setTimeout(() => {
+      s(n);
+    }, u);
+    return () => {
+      clearTimeout(c);
+    };
+  }, [n, u]), a;
+}
+function p(n, u = D, a = {}) {
+  const { leading: s = !1, trailing: c = !0, maxWait: m } = a, o = i(n), e = i(null), l = i(null), r = i(null), b = i(null);
+  T(() => {
+    o.current = n;
+  }, [n]);
+  const t = f(() => {
+    e.current && (clearTimeout(e.current), e.current = null), l.current && (clearTimeout(l.current), l.current = null), r.current = null, b.current = null;
+  }, []), R = f(() => {
+    r.current && (o.current(...r.current), t());
+  }, [t]), C = f(() => e.current !== null, []), g = f((...d) => {
+    r.current = d;
+    const k = Date.now();
+    s && !e.current && o.current(...d), e.current && clearTimeout(e.current), c && (e.current = setTimeout(() => {
+      r.current && c && o.current(...r.current), t();
+    }, u)), m !== void 0 && !l.current && (b.current = k, l.current = setTimeout(() => {
+      r.current && o.current(...r.current), t();
+    }, m));
+  }, [u, s, c, m, t]);
+  return T(() => () => {
+    t();
+  }, [t]), { callback: g, cancel: t, flush: R, isPending: C };
+}
+export {
+  E as useDebounce,
+  p as useDebouncedCallback
+};

package/dist/hooks/useDebounce/useDebounce.types.d.ts

@@ -0,0 +1,20 @@
+export interface UseDebounceOptions {
+    /** Delay in milliseconds */
+    delay?: number;
+    /** Execute on leading edge */
+    leading?: boolean;
+    /** Execute on trailing edge */
+    trailing?: boolean;
+    /** Maximum time to wait */
+    maxWait?: number;
+}
+export interface UseDebouncedCallbackReturn<T extends (...args: unknown[]) => unknown> {
+    /** Debounced function */
+    callback: T;
+    /** Cancel pending execution */
+    cancel: () => void;
+    /** Flush pending execution immediately */
+    flush: () => void;
+    /** Check if pending */
+    isPending: () => boolean;
+}

package/dist/hooks/useFloat/index.d.ts

@@ -0,0 +1,2 @@
+export { useFloat } from './useFloat';
+export type { UseFloatOptions, UseFloatReturn } from './useFloat.types';

package/dist/hooks/useFloat/useFloat.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const t=require("react");function g(s={}){const{distance:r=10,duration:c=3e3,delay:a=0,direction:l="vertical",autoStart:o=!0}=s,u=t.useRef(null),[n,i]=t.useState(!1),e=t.useCallback(()=>{i(!0)},[]),f=t.useCallback(()=>{i(!1)},[]);t.useEffect(()=>{if(o){const m=setTimeout(e,a);return()=>clearTimeout(m)}},[o,a,e]);const d=n?{animation:`${(()=>{switch(l){case"horizontal":return"float-horizontal";case"diagonal":return"float-diagonal";default:return"float-vertical"}})()} ${c}ms ease-in-out infinite`,"--float-distance":`${r}px`}:{};return{ref:u,style:d,isActive:n,start:e,stop:f}}exports.useFloat=g;

package/dist/hooks/useFloat/useFloat.d.ts

@@ -0,0 +1,2 @@
+import { UseFloatOptions, UseFloatReturn } from './useFloat.types';
+export declare function useFloat<T extends HTMLElement = HTMLDivElement>(options?: UseFloatOptions): UseFloatReturn<T>;

package/dist/hooks/useFloat/useFloat.js

@@ -0,0 +1,37 @@
+import { useRef as g, useState as p, useCallback as i, useEffect as v } from "react";
+function $(s = {}) {
+  const {
+    distance: r = 10,
+    duration: c = 3e3,
+    delay: e = 0,
+    direction: l = "vertical",
+    autoStart: a = !0
+  } = s, u = g(null), [o, n] = p(!1), t = i(() => {
+    n(!0);
+  }, []), f = i(() => {
+    n(!1);
+  }, []);
+  v(() => {
+    if (a) {
+      const d = setTimeout(t, e);
+      return () => clearTimeout(d);
+    }
+  }, [a, e, t]);
+  const m = o ? {
+    animation: `${(() => {
+      switch (l) {
+        case "horizontal":
+          return "float-horizontal";
+        case "diagonal":
+          return "float-diagonal";
+        default:
+          return "float-vertical";
+      }
+    })()} ${c}ms ease-in-out infinite`,
+    "--float-distance": `${r}px`
+  } : {};
+  return { ref: u, style: m, isActive: o, start: t, stop: f };
+}
+export {
+  $ as useFloat
+};

package/dist/hooks/useFloat/useFloat.types.d.ts

@@ -0,0 +1,25 @@
+import { RefObject, CSSProperties } from 'react';
+export interface UseFloatOptions {
+    /** Float distance in pixels */
+    distance?: number;
+    /** Duration of one float cycle (in ms) */
+    duration?: number;
+    /** Delay before starting (in ms) */
+    delay?: number;
+    /** Direction of float */
+    direction?: 'vertical' | 'horizontal' | 'diagonal';
+    /** Start animation on mount */
+    autoStart?: boolean;
+}
+export interface UseFloatReturn<T extends HTMLElement> {
+    /** Ref to attach to the element */
+    ref: RefObject<T>;
+    /** Style object to apply */
+    style: CSSProperties;
+    /** Whether floating is active */
+    isActive: boolean;
+    /** Start floating */
+    start: () => void;
+    /** Stop floating */
+    stop: () => void;
+}

package/dist/hooks/useIntersectionObserver/index.d.ts

@@ -0,0 +1,2 @@
+export { useIntersectionObserver, useInView } from './useIntersectionObserver';
+export type { UseIntersectionObserverOptions, UseIntersectionObserverReturn } from './useIntersectionObserver.types';

package/dist/hooks/useIntersectionObserver/useIntersectionObserver.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const u=require("react"),b=(t,s={})=>{const{threshold:n=0,root:l=null,rootMargin:f="0px",freezeOnceVisible:i=!1,enabled:a=!0,onChange:r}=s,[e,d]=u.useState(null),I=u.useRef(!1);return u.useEffect(()=>{if(!a||!t.current||typeof IntersectionObserver>"u"||I.current&&i)return;const c=new IntersectionObserver(([o])=>{d(o),r==null||r(o),i&&o.isIntersecting&&(I.current=!0,c.disconnect())},{threshold:n,root:l,rootMargin:f});return c.observe(t.current),()=>{c.disconnect()}},[t,n,l,f,i,a,r]),{isIntersecting:(e==null?void 0:e.isIntersecting)??!1,entry:e,intersectionRatio:(e==null?void 0:e.intersectionRatio)??0}},g=(t,s={})=>{const{isIntersecting:n}=b(t,s);return n};exports.useInView=g;exports.useIntersectionObserver=b;

package/dist/hooks/useIntersectionObserver/useIntersectionObserver.d.ts

@@ -0,0 +1,25 @@
+import { RefObject } from 'react';
+import { UseIntersectionObserverOptions, UseIntersectionObserverReturn } from './useIntersectionObserver.types';
+/**
+ * useIntersectionObserver - Detect when an element enters/leaves the viewport
+ *
+ * @example
+ * ```tsx
+ * const ref = useRef<HTMLDivElement>(null);
+ * const { isIntersecting, intersectionRatio } = useIntersectionObserver(ref, {
+ *   threshold: 0.5,
+ * });
+ *
+ * return (
+ *   <div ref={ref} style={{ opacity: isIntersecting ? 1 : 0.5 }}>
+ *     {isIntersecting ? 'Visible!' : 'Not visible'}
+ *   </div>
+ * );
+ * ```
+ */
+export declare const useIntersectionObserver: <T extends HTMLElement>(ref: RefObject<T>, options?: UseIntersectionObserverOptions) => UseIntersectionObserverReturn;
+/**
+ * useInView - Simple boolean for whether element is in view
+ */
+export declare const useInView: <T extends HTMLElement>(ref: RefObject<T>, options?: Omit<UseIntersectionObserverOptions, "onChange">) => boolean;
+export default useIntersectionObserver;

package/dist/hooks/useIntersectionObserver/useIntersectionObserver.js

@@ -0,0 +1,39 @@
+import { useState as d, useRef as b, useEffect as g } from "react";
+const p = (t, s = {}) => {
+  const {
+    threshold: n = 0,
+    root: u = null,
+    rootMargin: f = "0px",
+    freezeOnceVisible: i = !1,
+    enabled: l = !0,
+    onChange: r
+  } = s, [e, a] = d(null), I = b(!1);
+  return g(() => {
+    if (!l || !t.current || typeof IntersectionObserver > "u" || I.current && i)
+      return;
+    const c = new IntersectionObserver(
+      ([o]) => {
+        a(o), r == null || r(o), i && o.isIntersecting && (I.current = !0, c.disconnect());
+      },
+      {
+        threshold: n,
+        root: u,
+        rootMargin: f
+      }
+    );
+    return c.observe(t.current), () => {
+      c.disconnect();
+    };
+  }, [t, n, u, f, i, l, r]), {
+    isIntersecting: (e == null ? void 0 : e.isIntersecting) ?? !1,
+    entry: e,
+    intersectionRatio: (e == null ? void 0 : e.intersectionRatio) ?? 0
+  };
+}, v = (t, s = {}) => {
+  const { isIntersecting: n } = p(t, s);
+  return n;
+};
+export {
+  v as useInView,
+  p as useIntersectionObserver
+};

package/dist/hooks/useIntersectionObserver/useIntersectionObserver.types.d.ts

@@ -0,0 +1,22 @@
+export interface UseIntersectionObserverOptions {
+    /** Threshold(s) at which to trigger callback */
+    threshold?: number | number[];
+    /** Root element for intersection */
+    root?: Element | Document | null;
+    /** Margin around root */
+    rootMargin?: string;
+    /** Freeze updates after first intersection */
+    freezeOnceVisible?: boolean;
+    /** Whether the hook is enabled */
+    enabled?: boolean;
+    /** Callback when intersection changes */
+    onChange?: (entry: IntersectionObserverEntry) => void;
+}
+export interface UseIntersectionObserverReturn {
+    /** Whether element is visible */
+    isIntersecting: boolean;
+    /** Current intersection entry */
+    entry: IntersectionObserverEntry | null;
+    /** Intersection ratio (0-1) */
+    intersectionRatio: number;
+}

package/dist/hooks/useKeyPress/index.d.ts

@@ -0,0 +1,2 @@
+export { useKeyPress, useKeyPressState } from './useKeyPress';
+export type { UseKeyPressOptions, KeyFilter } from './useKeyPress.types';

package/dist/hooks/useKeyPress/useKeyPress.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const n=require("react"),P=(r,e)=>typeof e=="function"?e(r):(Array.isArray(e)?e:[e]).some(o=>{const s=o.toLowerCase();return r.key.toLowerCase()===s||r.code.toLowerCase()===s}),a=(r,e,f={})=>{const{target:o,event:s="keydown",preventDefault:c=!1,stopPropagation:i=!1,metaKey:l=!1,ctrlKey:y=!1,shiftKey:K=!1,altKey:d=!1}=f,p=n.useRef(e);n.useEffect(()=>{p.current=e},[e]);const u=n.useCallback(t=>{l&&!t.metaKey||y&&!t.ctrlKey||K&&!t.shiftKey||d&&!t.altKey||P(t,r)&&(c&&t.preventDefault(),i&&t.stopPropagation(),p.current(t))},[r,l,y,K,d,c,i]);n.useEffect(()=>{const t=o||document;return t.addEventListener(s,u),()=>{t.removeEventListener(s,u)}},[o,s,u])},m=r=>{const e=n.useRef(!1);return a(r,()=>{e.current=!0},{event:"keydown"}),a(r,()=>{e.current=!1},{event:"keyup"}),e.current};exports.useKeyPress=a;exports.useKeyPressState=m;

package/dist/hooks/useKeyPress/useKeyPress.d.ts

@@ -0,0 +1,22 @@
+import { UseKeyPressOptions, KeyFilter } from './useKeyPress.types';
+/**
+ * useKeyPress - Detect when a key is pressed
+ *
+ * @example
+ * ```tsx
+ * // Single key
+ * useKeyPress('Escape', () => closeModal());
+ *
+ * // Multiple keys
+ * useKeyPress(['ArrowUp', 'ArrowDown'], (e) => handleArrow(e));
+ *
+ * // With modifiers
+ * useKeyPress('k', () => openSearch(), { metaKey: true });
+ * ```
+ */
+export declare const useKeyPress: (key: KeyFilter, callback: (event: KeyboardEvent) => void, options?: UseKeyPressOptions) => void;
+/**
+ * useKeyPressState - Track if a key is currently pressed
+ */
+export declare const useKeyPressState: (key: KeyFilter) => boolean;
+export default useKeyPress;

package/dist/hooks/useKeyPress/useKeyPress.js

@@ -0,0 +1,39 @@
+import { useRef as m, useEffect as p, useCallback as v } from "react";
+const w = (r, e) => typeof e == "function" ? e(r) : (Array.isArray(e) ? e : [e]).some((n) => {
+  const s = n.toLowerCase();
+  return r.key.toLowerCase() === s || r.code.toLowerCase() === s;
+}), d = (r, e, a = {}) => {
+  const {
+    target: n,
+    event: s = "keydown",
+    preventDefault: f = !1,
+    stopPropagation: u = !1,
+    metaKey: c = !1,
+    ctrlKey: i = !1,
+    shiftKey: l = !1,
+    altKey: y = !1
+  } = a, K = m(e);
+  p(() => {
+    K.current = e;
+  }, [e]);
+  const o = v((t) => {
+    c && !t.metaKey || i && !t.ctrlKey || l && !t.shiftKey || y && !t.altKey || w(t, r) && (f && t.preventDefault(), u && t.stopPropagation(), K.current(t));
+  }, [r, c, i, l, y, f, u]);
+  p(() => {
+    const t = n || document;
+    return t.addEventListener(s, o), () => {
+      t.removeEventListener(s, o);
+    };
+  }, [n, s, o]);
+}, P = (r) => {
+  const e = m(!1);
+  return d(r, () => {
+    e.current = !0;
+  }, { event: "keydown" }), d(r, () => {
+    e.current = !1;
+  }, { event: "keyup" }), e.current;
+};
+export {
+  d as useKeyPress,
+  P as useKeyPressState
+};

package/dist/hooks/useKeyPress/useKeyPress.types.d.ts

@@ -0,0 +1,19 @@
+export interface UseKeyPressOptions {
+    /** Target element (defaults to document) */
+    target?: HTMLElement | null;
+    /** Event type */
+    event?: 'keydown' | 'keyup' | 'keypress';
+    /** Prevent default behavior */
+    preventDefault?: boolean;
+    /** Stop propagation */
+    stopPropagation?: boolean;
+    /** Only trigger when meta key is pressed */
+    metaKey?: boolean;
+    /** Only trigger when ctrl key is pressed */
+    ctrlKey?: boolean;
+    /** Only trigger when shift key is pressed */
+    shiftKey?: boolean;
+    /** Only trigger when alt key is pressed */
+    altKey?: boolean;
+}
+export type KeyFilter = string | string[] | ((event: KeyboardEvent) => boolean);

package/dist/hooks/useLocalStorage/index.d.ts

@@ -0,0 +1,2 @@
+export { useLocalStorage } from './useLocalStorage';
+export type { UseLocalStorageOptions, UseLocalStorageReturn } from './useLocalStorage.types';

package/dist/hooks/useLocalStorage/useLocalStorage.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const a=require("react"),g=e=>JSON.stringify(e),S=e=>JSON.parse(e);function m(e,t,u={}){const{serializer:l=g,deserializer:c=S,syncTabs:d=!0}=u,[s,n]=a.useState(()=>{if(typeof window>"u")return t;try{const r=window.localStorage.getItem(e);return r?c(r):t}catch(r){return console.warn(`Error reading localStorage key "${e}":`,r),t}}),i=a.useCallback(r=>{try{const o=r instanceof Function?r(s):r;n(o),typeof window<"u"&&window.localStorage.setItem(e,l(o))}catch(o){console.warn(`Error setting localStorage key "${e}":`,o)}},[e,s,l]),w=a.useCallback(()=>{try{n(t),typeof window<"u"&&window.localStorage.removeItem(e)}catch(r){console.warn(`Error removing localStorage key "${e}":`,r)}},[e,t]);return a.useEffect(()=>{if(!d||typeof window>"u")return;const r=o=>{if(o.key===e&&o.newValue!==null)try{n(c(o.newValue))}catch(f){console.warn(`Error syncing localStorage key "${e}":`,f)}else o.key===e&&o.newValue===null&&n(t)};return window.addEventListener("storage",r),()=>window.removeEventListener("storage",r)},[e,t,c,d]),[s,i,w]}exports.useLocalStorage=m;

package/dist/hooks/useLocalStorage/useLocalStorage.d.ts

@@ -0,0 +1,11 @@
+import { UseLocalStorageOptions, UseLocalStorageReturn } from './useLocalStorage.types';
+/**
+ * useLocalStorage - Persist state in localStorage
+ *
+ * @example
+ * ```tsx
+ * const [theme, setTheme, removeTheme] = useLocalStorage('theme', 'light');
+ * ```
+ */
+export declare function useLocalStorage<T>(key: string, initialValue: T, options?: UseLocalStorageOptions<T>): UseLocalStorageReturn<T>;
+export default useLocalStorage;

package/dist/hooks/useLocalStorage/useLocalStorage.js

@@ -0,0 +1,47 @@
+import { useState as g, useCallback as d, useEffect as S } from "react";
+const m = (e) => JSON.stringify(e), p = (e) => JSON.parse(e);
+function h(e, t, w = {}) {
+  const {
+    serializer: s = m,
+    deserializer: a = p,
+    syncTabs: l = !0
+  } = w, [c, n] = g(() => {
+    if (typeof window > "u")
+      return t;
+    try {
+      const r = window.localStorage.getItem(e);
+      return r ? a(r) : t;
+    } catch (r) {
+      return console.warn(`Error reading localStorage key "${e}":`, r), t;
+    }
+  }), f = d((r) => {
+    try {
+      const o = r instanceof Function ? r(c) : r;
+      n(o), typeof window < "u" && window.localStorage.setItem(e, s(o));
+    } catch (o) {
+      console.warn(`Error setting localStorage key "${e}":`, o);
+    }
+  }, [e, c, s]), i = d(() => {
+    try {
+      n(t), typeof window < "u" && window.localStorage.removeItem(e);
+    } catch (r) {
+      console.warn(`Error removing localStorage key "${e}":`, r);
+    }
+  }, [e, t]);
+  return S(() => {
+    if (!l || typeof window > "u") return;
+    const r = (o) => {
+      if (o.key === e && o.newValue !== null)
+        try {
+          n(a(o.newValue));
+        } catch (u) {
+          console.warn(`Error syncing localStorage key "${e}":`, u);
+        }
+      else o.key === e && o.newValue === null && n(t);
+    };
+    return window.addEventListener("storage", r), () => window.removeEventListener("storage", r);
+  }, [e, t, a, l]), [c, f, i];
+}
+export {
+  h as useLocalStorage
+};

package/dist/hooks/useLocalStorage/useLocalStorage.types.d.ts

@@ -0,0 +1,16 @@
+export interface UseLocalStorageOptions<T> {
+    /** Serializer function */
+    serializer?: (value: T) => string;
+    /** Deserializer function */
+    deserializer?: (value: string) => T;
+    /** Sync across tabs */
+    syncTabs?: boolean;
+}
+export type UseLocalStorageReturn<T> = [
+    /** Current value */
+    T,
+    /** Set value */
+    (value: T | ((prev: T) => T)) => void,
+    /** Remove value */
+    () => void
+];

package/dist/hooks/useMediaQuery/index.d.ts

@@ -0,0 +1,3 @@
+export { useMediaQuery } from './useMediaQuery';
+export { BREAKPOINTS } from './useMediaQuery.types';
+export type { UseMediaQueryOptions, UseMediaQueryReturn, BreakpointKey } from './useMediaQuery.types';

package/dist/hooks/useMediaQuery/useMediaQuery.d.ts

@@ -0,0 +1,12 @@
+import { UseMediaQueryOptions, UseMediaQueryReturn, BreakpointKey } from './useMediaQuery.types';
+/**
+ * useMediaQuery - Track media query matches
+ *
+ * @example
+ * ```tsx
+ * const isMobile = useMediaQuery('(max-width: 768px)');
+ * const isDark = useMediaQuery('dark'); // Uses predefined breakpoint
+ * ```
+ */
+export declare const useMediaQuery: (query: string | BreakpointKey, options?: UseMediaQueryOptions) => UseMediaQueryReturn;
+export default useMediaQuery;