@forgedevstack/bear 1.0.7 → 1.0.8

package/dist/hooks/useBearComponent/useBearComponent.d.ts

@@ -0,0 +1,71 @@
+import { ReactNode } from 'react';
+import { BearComponentOverrides, ButtonVariantsConfig } from '../../types/component.types';
+import { UseBearComponentReturn, BearComponentContextValue } from './useBearComponent.types';
+interface BearComponentProviderProps {
+    children: ReactNode;
+    /** Initial component overrides */
+    components?: BearComponentOverrides;
+    /** Initial variant configurations */
+    variants?: {
+        Button?: ButtonVariantsConfig;
+    };
+}
+/**
+ * Provider for global component customization
+ *
+ * @example
+ * ```tsx
+ * <BearComponentProvider
+ *   components={{
+ *     Button: {
+ *       root: { borderRadius: '9999px' }
+ *     }
+ *   }}
+ *   variants={{
+ *     Button: {
+ *       primary: {
+ *         bg: '#ec4899',
+ *         bgHover: '#db2777',
+ *         text: '#ffffff'
+ *       }
+ *     }
+ *   }}
+ * >
+ *   <App />
+ * </BearComponentProvider>
+ * ```
+ */
+export declare const BearComponentProvider: ({ children, components: initialComponents, variants: initialVariants, }: BearComponentProviderProps) => import("react/jsx-runtime").JSX.Element;
+/**
+ * Access the component customization context
+ */
+export declare const useBearComponentContext: () => BearComponentContextValue | null;
+/**
+ * Hook to get and apply component style overrides
+ *
+ * @param componentKey - The component key (e.g., 'Button', 'Input')
+ * @param defaultStyles - Optional default styles to merge with
+ *
+ * @example
+ * ```tsx
+ * // Inside a component
+ * const { getStyles, mergeStyles, hasOverrides } = useBearComponent('Button');
+ *
+ * return (
+ *   <button style={mergeStyles('root', { padding: '8px' })}>
+ *     <span style={getStyles('text')}>Click me</span>
+ *   </button>
+ * );
+ * ```
+ */
+export declare const useBearComponent: <K extends keyof BearComponentOverrides>(componentKey: K, defaultStyles?: BearComponentOverrides[K]) => UseBearComponentReturn;
+/**
+ * Shorthand alias for useBearComponent
+ *
+ * @example
+ * ```tsx
+ * const { getStyles } = useBC('Button');
+ * ```
+ */
+export declare const useBC: <K extends keyof BearComponentOverrides>(componentKey: K, defaultStyles?: BearComponentOverrides[K]) => UseBearComponentReturn;
+export {};

package/dist/hooks/useBearComponent/useBearComponent.js

@@ -0,0 +1,54 @@
+import { jsx as b } from "react/jsx-runtime";
+import { createContext as O, useState as d, useCallback as r, useMemo as y, useContext as x } from "react";
+const v = O(null), h = ({
+  children: p,
+  components: m = {},
+  variants: u = {}
+}) => {
+  const [t, c] = d(m), [a, l] = d(u), o = r((e, S) => {
+    c((i) => ({
+      ...i,
+      [e]: {
+        ...i[e] || {},
+        ...S
+      }
+    }));
+  }, []), n = r((e, S) => {
+    l((i) => ({
+      ...i,
+      [e]: {
+        ...i[e] || {},
+        ...S
+      }
+    }));
+  }, []), s = r((e) => t[e], [t]), C = r((e) => a[e], [a]), g = r(() => {
+    c({}), l({});
+  }, []), B = y(() => ({
+    components: t,
+    variants: a,
+    registerComponent: o,
+    registerVariant: n,
+    getComponentStyles: s,
+    getVariantConfig: C,
+    clearOverrides: g
+  }), [t, a, o, n, s, C, g]);
+  return /* @__PURE__ */ b(v.Provider, { value: B, children: p });
+}, j = () => x(v), P = (p, m) => {
+  const u = x(v), t = u == null ? void 0 : u.components[p], c = r((o = "root") => {
+    const n = t, s = m, C = n == null ? void 0 : n[o];
+    return {
+      ...(s == null ? void 0 : s[o]) || {},
+      ...C || {}
+    };
+  }, [t, m]), a = r((o = "root", n) => ({
+    ...c(o),
+    ...n || {}
+  }), [c]), l = y(() => t !== void 0 && Object.keys(t).length > 0, [t]);
+  return { getStyles: c, mergeStyles: a, hasOverrides: l };
+}, k = P;
+export {
+  h as BearComponentProvider,
+  k as useBC,
+  P as useBearComponent,
+  j as useBearComponentContext
+};

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

@@ -0,0 +1,40 @@
+import { CSSProperties } from 'react';
+import { BearComponentOverrides, ButtonVariantsConfig } from '../../types/component.types';
+/**
+ * Component part style definition
+ */
+export interface ComponentPartStyles {
+    [part: string]: CSSProperties;
+}
+/**
+ * Return type for useBearComponent hook
+ */
+export interface UseBearComponentReturn {
+    /** Get styles for a specific component part */
+    getStyles: (part?: string) => CSSProperties;
+    /** Merge with additional styles */
+    mergeStyles: (part: string | undefined, additionalStyles?: CSSProperties) => CSSProperties;
+    /** Check if component has overrides */
+    hasOverrides: boolean;
+}
+/**
+ * Context value for component customization
+ */
+export interface BearComponentContextValue {
+    /** Component style overrides */
+    components: BearComponentOverrides;
+    /** Variant configurations */
+    variants: {
+        Button?: ButtonVariantsConfig;
+    };
+    /** Register component overrides */
+    registerComponent: <K extends keyof BearComponentOverrides>(componentKey: K, styles: BearComponentOverrides[K]) => void;
+    /** Register variant overrides */
+    registerVariant: <K extends 'Button'>(componentKey: K, variantConfig: ButtonVariantsConfig) => void;
+    /** Get component styles */
+    getComponentStyles: <K extends keyof BearComponentOverrides>(componentKey: K) => BearComponentOverrides[K] | undefined;
+    /** Get variant config */
+    getVariantConfig: <K extends 'Button'>(componentKey: K) => ButtonVariantsConfig | undefined;
+    /** Clear all overrides */
+    clearOverrides: () => void;
+}

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

@@ -0,0 +1,2 @@
+export { useIdle } from './useIdle';
+export type { UseIdleOptions, UseIdleReturn } from './useIdle.types';

package/dist/hooks/useIdle/useIdle.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("react"),y=["mousemove","mousedown","keydown","touchstart","scroll","wheel"],A=6e4;function L(S={}){const{timeout:a=A,events:f=y,initialState:k=!1,onIdle:d,onActive:m}=S,[w,v]=e.useState(k),[D,I]=e.useState(Date.now()),[h,T]=e.useState(a),[c,b]=e.useState(!1),o=e.useRef(null),r=e.useRef(null),l=e.useRef(d),i=e.useRef(m);e.useEffect(()=>{l.current=d,i.current=m},[d,m]);const u=e.useCallback(()=>{o.current&&(clearTimeout(o.current),o.current=null),r.current&&(clearInterval(r.current),r.current=null)},[]),t=e.useCallback(()=>{if(c)return;u();const s=Date.now();T(a),r.current=setInterval(()=>{const n=Date.now()-s;T(Math.max(0,a-n))},1e3),o.current=setTimeout(()=>{var n;v(!0),(n=l.current)==null||n.call(l),r.current&&clearInterval(r.current)},a)},[a,c,u]),E=e.useCallback(()=>{var n;if(c)return;const s=w;v(!1),I(Date.now()),t(),s&&((n=i.current)==null||n.call(i))},[c,w,t]),C=e.useCallback(()=>{v(!1),I(Date.now()),t()},[t]),R=e.useCallback(()=>{b(!0),u()},[u]),p=e.useCallback(()=>{b(!1),t()},[t]);return e.useEffect(()=>{if(!(typeof window>"u"))return t(),f.forEach(s=>{window.addEventListener(s,E,{passive:!0})}),()=>{u(),f.forEach(s=>{window.removeEventListener(s,E)})}},[f,E,t,u]),{isIdle:w,remaining:h,lastActive:D,reset:C,pause:R,resume:p}}exports.useIdle=L;

package/dist/hooks/useIdle/useIdle.d.ts

@@ -0,0 +1,22 @@
+import { UseIdleOptions, UseIdleReturn } from './useIdle.types';
+/**
+ * useIdle - Detect user inactivity
+ *
+ * @example
+ * ```tsx
+ * const { isIdle, remaining, reset } = useIdle({
+ *   timeout: 30000, // 30 seconds
+ *   onIdle: () => console.log('User is idle'),
+ *   onActive: () => console.log('User is active'),
+ * });
+ *
+ * return (
+ *   <div>
+ *     {isIdle ? 'User is idle' : `Active (${remaining}ms until idle)`}
+ *     <button onClick={reset}>Reset</button>
+ *   </div>
+ * );
+ * ```
+ */
+export declare function useIdle(options?: UseIdleOptions): UseIdleReturn;
+export default useIdle;

package/dist/hooks/useIdle/useIdle.js

@@ -0,0 +1,66 @@
+import { useState as f, useRef as d, useEffect as A, useCallback as c } from "react";
+const F = [
+  "mousemove",
+  "mousedown",
+  "keydown",
+  "touchstart",
+  "scroll",
+  "wheel"
+], M = 6e4;
+function R(L = {}) {
+  const {
+    timeout: o = M,
+    events: m = F,
+    initialState: y = !1,
+    onIdle: w,
+    onActive: v
+  } = L, [E, I] = f(y), [S, D] = f(Date.now()), [U, h] = f(o), [u, p] = f(!1), a = d(null), r = d(null), i = d(w), l = d(v);
+  A(() => {
+    i.current = w, l.current = v;
+  }, [w, v]);
+  const s = c(() => {
+    a.current && (clearTimeout(a.current), a.current = null), r.current && (clearInterval(r.current), r.current = null);
+  }, []), e = c(() => {
+    if (u) return;
+    s();
+    const t = Date.now();
+    h(o), r.current = setInterval(() => {
+      const n = Date.now() - t;
+      h(Math.max(0, o - n));
+    }, 1e3), a.current = setTimeout(() => {
+      var n;
+      I(!0), (n = i.current) == null || n.call(i), r.current && clearInterval(r.current);
+    }, o);
+  }, [o, u, s]), T = c(() => {
+    var n;
+    if (u) return;
+    const t = E;
+    I(!1), D(Date.now()), e(), t && ((n = l.current) == null || n.call(l));
+  }, [u, E, e]), g = c(() => {
+    I(!1), D(Date.now()), e();
+  }, [e]), k = c(() => {
+    p(!0), s();
+  }, [s]), x = c(() => {
+    p(!1), e();
+  }, [e]);
+  return A(() => {
+    if (!(typeof window > "u"))
+      return e(), m.forEach((t) => {
+        window.addEventListener(t, T, { passive: !0 });
+      }), () => {
+        s(), m.forEach((t) => {
+          window.removeEventListener(t, T);
+        });
+      };
+  }, [m, T, e, s]), {
+    isIdle: E,
+    remaining: U,
+    lastActive: S,
+    reset: g,
+    pause: k,
+    resume: x
+  };
+}
+export {
+  R as useIdle
+};

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

@@ -0,0 +1,29 @@
+/**
+ * useIdle hook types
+ */
+export interface UseIdleOptions {
+    /** Timeout in milliseconds before user is considered idle (default: 60000 = 1 min) */
+    timeout?: number;
+    /** Events to listen for as activity (default: mouse, keyboard, touch, scroll) */
+    events?: (keyof WindowEventMap)[];
+    /** Initial idle state */
+    initialState?: boolean;
+    /** Callback when user becomes idle */
+    onIdle?: () => void;
+    /** Callback when user becomes active */
+    onActive?: () => void;
+}
+export interface UseIdleReturn {
+    /** Whether the user is currently idle */
+    isIdle: boolean;
+    /** Time remaining until idle (ms) */
+    remaining: number;
+    /** Last activity timestamp */
+    lastActive: number;
+    /** Reset the idle timer */
+    reset: () => void;
+    /** Pause idle detection */
+    pause: () => void;
+    /** Resume idle detection */
+    resume: () => void;
+}

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

@@ -0,0 +1,2 @@
+export { useLongPress } from './useLongPress';
+export type { UseLongPressOptions, UseLongPressReturn } from './useLongPress.types';

package/dist/hooks/useLongPress/useLongPress.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const t=require("react"),p=400;function D(d={}){const{threshold:R=p,onLongPress:s,onClick:i,onStart:u,onFinish:c,onCancel:n,filterEvents:b,disabled:C=!1}=d,l=t.useRef(null),k=t.useRef(!1),r=t.useRef(!1),E=t.useRef(null),o=t.useCallback(()=>{l.current&&(clearTimeout(l.current),l.current=null)},[]),a=t.useCallback(e=>{C||b&&!b(e)||(r.current=!0,k.current=!1,E.current=e,u==null||u(e),l.current=setTimeout(()=>{k.current=!0,s==null||s(e)},R))},[C,b,u,s,R]),T=t.useCallback(e=>{r.current&&(o(),r.current=!1,n==null||n(e))},[o,n]),f=t.useCallback(e=>{r.current&&(o(),r.current=!1,!k.current&&i&&i(e),c==null||c(e))},[o,i,c]),L=t.useCallback(e=>{e.button===0&&a(e)},[a]),g=t.useCallback(e=>{f(e)},[f]),m=t.useCallback(e=>{T(e)},[T]),M=t.useCallback(e=>{a(e)},[a]),h=t.useCallback(e=>{f(e)},[f]);return{onMouseDown:L,onMouseUp:g,onMouseLeave:m,onTouchStart:M,onTouchEnd:h}}exports.useLongPress=D;

package/dist/hooks/useLongPress/useLongPress.d.ts

@@ -0,0 +1,17 @@
+import { UseLongPressOptions, UseLongPressReturn } from './useLongPress.types';
+/**
+ * useLongPress - Detect long press gestures
+ *
+ * @example
+ * ```tsx
+ * const longPressProps = useLongPress({
+ *   threshold: 500,
+ *   onLongPress: () => console.log('Long pressed!'),
+ *   onClick: () => console.log('Clicked!'),
+ * });
+ *
+ * return <button {...longPressProps}>Hold me</button>;
+ * ```
+ */
+export declare function useLongPress(options?: UseLongPressOptions): UseLongPressReturn;
+export default useLongPress;

package/dist/hooks/useLongPress/useLongPress.js

@@ -0,0 +1,44 @@
+import { useRef as a, useCallback as t } from "react";
+const H = 400;
+function g(L = {}) {
+  const {
+    threshold: E = H,
+    onLongPress: n,
+    onClick: R,
+    onStart: c,
+    onFinish: s,
+    onCancel: u,
+    filterEvents: T,
+    disabled: d = !1
+  } = L, o = a(null), m = a(!1), e = a(!1), b = a(null), f = t(() => {
+    o.current && (clearTimeout(o.current), o.current = null);
+  }, []), l = t((r) => {
+    d || T && !T(r) || (e.current = !0, m.current = !1, b.current = r, c == null || c(r), o.current = setTimeout(() => {
+      m.current = !0, n == null || n(r);
+    }, E));
+  }, [d, T, c, n, E]), p = t((r) => {
+    e.current && (f(), e.current = !1, u == null || u(r));
+  }, [f, u]), i = t((r) => {
+    e.current && (f(), e.current = !1, !m.current && R && R(r), s == null || s(r));
+  }, [f, R, s]), h = t((r) => {
+    r.button === 0 && l(r);
+  }, [l]), D = t((r) => {
+    i(r);
+  }, [i]), M = t((r) => {
+    p(r);
+  }, [p]), k = t((r) => {
+    l(r);
+  }, [l]), A = t((r) => {
+    i(r);
+  }, [i]);
+  return {
+    onMouseDown: h,
+    onMouseUp: D,
+    onMouseLeave: M,
+    onTouchStart: k,
+    onTouchEnd: A
+  };
+}
+export {
+  g as useLongPress
+};

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

@@ -0,0 +1,26 @@
+import { MouseEvent, TouchEvent } from 'react';
+export interface UseLongPressOptions {
+    /** Duration in ms to trigger long press (default: 400) */
+    threshold?: number;
+    /** Callback for long press */
+    onLongPress?: (event: MouseEvent | TouchEvent) => void;
+    /** Callback for regular click (if released before threshold) */
+    onClick?: (event: MouseEvent | TouchEvent) => void;
+    /** Callback when press starts */
+    onStart?: (event: MouseEvent | TouchEvent) => void;
+    /** Callback when press ends (regardless of long press) */
+    onFinish?: (event: MouseEvent | TouchEvent) => void;
+    /** Callback when press is cancelled (e.g., mouse leaves) */
+    onCancel?: (event: MouseEvent | TouchEvent) => void;
+    /** Filter function to determine if event should trigger */
+    filterEvents?: (event: MouseEvent | TouchEvent) => boolean;
+    /** Disable the long press */
+    disabled?: boolean;
+}
+export interface UseLongPressReturn {
+    onMouseDown: (event: MouseEvent) => void;
+    onMouseUp: (event: MouseEvent) => void;
+    onMouseLeave: (event: MouseEvent) => void;
+    onTouchStart: (event: TouchEvent) => void;
+    onTouchEnd: (event: TouchEvent) => void;
+}

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

@@ -0,0 +1,2 @@
+export { useOnline } from './useOnline';
+export type { UseOnlineOptions, UseOnlineReturn } from './useOnline.types';

package/dist/hooks/useOnline/useOnline.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("react");function w(a={}){const{onOnline:o,onOffline:r}=a,[f,c]=e.useState(()=>typeof navigator<"u"?navigator.onLine:!0),[d,l]=e.useState(null),t=e.useRef(o),i=e.useRef(r);e.useEffect(()=>{t.current=o,i.current=r},[o,r]);const s=e.useCallback(()=>{var n;c(!0),l(Date.now()),(n=t.current)==null||n.call(t)},[]),u=e.useCallback(()=>{var n;c(!1),l(Date.now()),(n=i.current)==null||n.call(i)},[]);return e.useEffect(()=>{if(!(typeof window>"u"))return window.addEventListener("online",s),window.addEventListener("offline",u),()=>{window.removeEventListener("online",s),window.removeEventListener("offline",u)}},[s,u]),{isOnline:f,since:d}}exports.useOnline=w;

package/dist/hooks/useOnline/useOnline.d.ts

@@ -0,0 +1,16 @@
+import { UseOnlineOptions, UseOnlineReturn } from './useOnline.types';
+/**
+ * useOnline - Detect online/offline network status
+ *
+ * @example
+ * ```tsx
+ * const { isOnline, since } = useOnline({
+ *   onOnline: () => console.log('Back online!'),
+ *   onOffline: () => console.log('Gone offline!'),
+ * });
+ *
+ * return <div>{isOnline ? '🟢 Online' : '🔴 Offline'}</div>;
+ * ```
+ */
+export declare function useOnline(options?: UseOnlineOptions): UseOnlineReturn;
+export default useOnline;

package/dist/hooks/useOnline/useOnline.js

@@ -0,0 +1,25 @@
+import { useState as l, useRef as d, useEffect as f, useCallback as a } from "react";
+function O(w = {}) {
+  const { onOnline: i, onOffline: o } = w, [v, u] = l(
+    () => typeof navigator < "u" ? navigator.onLine : !0
+  ), [E, c] = l(null), e = d(i), t = d(o);
+  f(() => {
+    e.current = i, t.current = o;
+  }, [i, o]);
+  const r = a(() => {
+    var n;
+    u(!0), c(Date.now()), (n = e.current) == null || n.call(e);
+  }, []), s = a(() => {
+    var n;
+    u(!1), c(Date.now()), (n = t.current) == null || n.call(t);
+  }, []);
+  return f(() => {
+    if (!(typeof window > "u"))
+      return window.addEventListener("online", r), window.addEventListener("offline", s), () => {
+        window.removeEventListener("online", r), window.removeEventListener("offline", s);
+      };
+  }, [r, s]), { isOnline: v, since: E };
+}
+export {
+  O as useOnline
+};

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

@@ -0,0 +1,15 @@
+/**
+ * useOnline hook types
+ */
+export interface UseOnlineOptions {
+    /** Callback when going online */
+    onOnline?: () => void;
+    /** Callback when going offline */
+    onOffline?: () => void;
+}
+export interface UseOnlineReturn {
+    /** Whether the browser is currently online */
+    isOnline: boolean;
+    /** Time since last status change (ms) */
+    since: number | null;
+}

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

@@ -0,0 +1,2 @@
+export { usePageVisibility } from './usePageVisibility';
+export type { UsePageVisibilityOptions, UsePageVisibilityReturn } from './usePageVisibility.types';

package/dist/hooks/usePageVisibility/usePageVisibility.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("react");function b(a={}){const{onVisible:n,onHidden:s}=a,[r,d]=e.useState(()=>typeof document<"u"?document.visibilityState:"visible"),i=e.useRef(n),t=e.useRef(s);e.useEffect(()=>{i.current=n,t.current=s},[n,s]);const u=e.useCallback(()=>{var o,l;const c=document.visibilityState;d(c),c==="visible"?(o=i.current)==null||o.call(i):c==="hidden"&&((l=t.current)==null||l.call(t))},[]);return e.useEffect(()=>{if(!(typeof document>"u"))return document.addEventListener("visibilitychange",u),()=>{document.removeEventListener("visibilitychange",u)}},[u]),{isVisible:r==="visible",visibilityState:r}}exports.usePageVisibility=b;

package/dist/hooks/usePageVisibility/usePageVisibility.d.ts

@@ -0,0 +1,19 @@
+import { UsePageVisibilityOptions, UsePageVisibilityReturn } from './usePageVisibility.types';
+/**
+ * usePageVisibility - Detect when page/tab is visible or hidden
+ *
+ * @example
+ * ```tsx
+ * const { isVisible, visibilityState } = usePageVisibility({
+ *   onVisible: () => console.log('Tab is visible'),
+ *   onHidden: () => console.log('Tab is hidden'),
+ * });
+ *
+ * // Pause video when tab is hidden
+ * useEffect(() => {
+ *   if (!isVisible) videoRef.current?.pause();
+ * }, [isVisible]);
+ * ```
+ */
+export declare function usePageVisibility(options?: UsePageVisibilityOptions): UsePageVisibilityReturn;
+export default usePageVisibility;

package/dist/hooks/usePageVisibility/usePageVisibility.js

@@ -0,0 +1,26 @@
+import { useState as v, useRef as l, useEffect as d, useCallback as f } from "react";
+function m(a = {}) {
+  const { onVisible: t, onHidden: n } = a, [u, b] = v(
+    () => typeof document < "u" ? document.visibilityState : "visible"
+  ), e = l(t), i = l(n);
+  d(() => {
+    e.current = t, i.current = n;
+  }, [t, n]);
+  const s = f(() => {
+    var r, o;
+    const c = document.visibilityState;
+    b(c), c === "visible" ? (r = e.current) == null || r.call(e) : c === "hidden" && ((o = i.current) == null || o.call(i));
+  }, []);
+  return d(() => {
+    if (!(typeof document > "u"))
+      return document.addEventListener("visibilitychange", s), () => {
+        document.removeEventListener("visibilitychange", s);
+      };
+  }, [s]), {
+    isVisible: u === "visible",
+    visibilityState: u
+  };
+}
+export {
+  m as usePageVisibility
+};

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

@@ -0,0 +1,15 @@
+/**
+ * usePageVisibility hook types
+ */
+export interface UsePageVisibilityOptions {
+    /** Callback when page becomes visible */
+    onVisible?: () => void;
+    /** Callback when page becomes hidden */
+    onHidden?: () => void;
+}
+export interface UsePageVisibilityReturn {
+    /** Whether the page is currently visible */
+    isVisible: boolean;
+    /** Document visibility state */
+    visibilityState: DocumentVisibilityState;
+}

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

@@ -0,0 +1,2 @@
+export { useSpotlight } from './useSpotlight';
+export type { UseSpotlightOptions, UseSpotlightReturn } from './useSpotlight.types';

package/dist/hooks/useSpotlight/useSpotlight.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("react"),h=(b={})=>{const{size:o=120,color:r="rgba(255, 255, 255, 0.15)",enabled:t=!0}=b,s=e.useRef(null),[n,g]=e.useState({x:0,y:0}),[i,a]=e.useState(!1),c=e.useCallback(p=>{if(!t||!s.current)return;const d=s.current.getBoundingClientRect();g({x:p.clientX-d.left,y:p.clientY-d.top})},[t]),u=e.useCallback(()=>{t&&a(!0)},[t]),l=e.useCallback(()=>{a(!1)},[]),y=e.useMemo(()=>!t||!i?{position:"absolute",pointerEvents:"none",opacity:0,transition:"opacity 0.2s ease"}:{position:"absolute",pointerEvents:"none",left:n.x-o/2,top:n.y-o/2,width:o,height:o,borderRadius:"50%",background:`radial-gradient(circle, ${r} 0%, transparent 70%)`,opacity:1,transition:"opacity 0.2s ease",zIndex:0},[t,i,n.x,n.y,o,r]),f=e.useMemo(()=>({onMouseMove:c,onMouseEnter:u,onMouseLeave:l}),[c,u,l]);return{ref:s,spotlightStyle:y,isHovered:i,handlers:f}};exports.useSpotlight=h;

package/dist/hooks/useSpotlight/useSpotlight.d.ts

@@ -0,0 +1,24 @@
+import { UseSpotlightOptions, UseSpotlightReturn } from './useSpotlight.types';
+/**
+ * Hook for mouse-follow spotlight/hover effect
+ *
+ * @example
+ * ```tsx
+ * const { ref, spotlightStyle, handlers } = useSpotlight({
+ *   size: 100,
+ *   color: 'rgba(255, 255, 255, 0.15)'
+ * });
+ *
+ * return (
+ *   <button
+ *     ref={ref}
+ *     {...handlers}
+ *     style={{ position: 'relative', overflow: 'hidden' }}
+ *   >
+ *     <span style={spotlightStyle} />
+ *     Click me
+ *   </button>
+ * );
+ * ```
+ */
+export declare const useSpotlight: (options?: UseSpotlightOptions) => UseSpotlightReturn;

package/dist/hooks/useSpotlight/useSpotlight.js

@@ -0,0 +1,49 @@
+import { useRef as x, useState as f, useCallback as r, useMemo as y } from "react";
+const m = (g = {}) => {
+  const {
+    size: e = 120,
+    color: i = "rgba(255, 255, 255, 0.15)",
+    enabled: t = !0
+  } = g, n = x(null), [o, b] = f({ x: 0, y: 0 }), [s, a] = f(!1), c = r((p) => {
+    if (!t || !n.current) return;
+    const d = n.current.getBoundingClientRect();
+    b({
+      x: p.clientX - d.left,
+      y: p.clientY - d.top
+    });
+  }, [t]), u = r(() => {
+    t && a(!0);
+  }, [t]), l = r(() => {
+    a(!1);
+  }, []), h = y(() => !t || !s ? {
+    position: "absolute",
+    pointerEvents: "none",
+    opacity: 0,
+    transition: "opacity 0.2s ease"
+  } : {
+    position: "absolute",
+    pointerEvents: "none",
+    left: o.x - e / 2,
+    top: o.y - e / 2,
+    width: e,
+    height: e,
+    borderRadius: "50%",
+    background: `radial-gradient(circle, ${i} 0%, transparent 70%)`,
+    opacity: 1,
+    transition: "opacity 0.2s ease",
+    zIndex: 0
+  }, [t, s, o.x, o.y, e, i]), v = y(() => ({
+    onMouseMove: c,
+    onMouseEnter: u,
+    onMouseLeave: l
+  }), [c, u, l]);
+  return {
+    ref: n,
+    spotlightStyle: h,
+    isHovered: s,
+    handlers: v
+  };
+};
+export {
+  m as useSpotlight
+};

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

@@ -0,0 +1,23 @@
+import { RefObject, CSSProperties } from 'react';
+export interface UseSpotlightOptions {
+    /** Size of the spotlight in pixels */
+    size?: number;
+    /** Color of the spotlight (with alpha) */
+    color?: string;
+    /** Whether spotlight is enabled */
+    enabled?: boolean;
+}
+export interface UseSpotlightReturn {
+    /** Ref to attach to the element */
+    ref: RefObject<HTMLElement | null>;
+    /** Style object for the spotlight overlay */
+    spotlightStyle: CSSProperties;
+    /** Whether mouse is currently over the element */
+    isHovered: boolean;
+    /** Event handlers to attach */
+    handlers: {
+        onMouseMove: (e: React.MouseEvent) => void;
+        onMouseEnter: () => void;
+        onMouseLeave: () => void;
+    };
+}

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

@@ -0,0 +1,2 @@
+export { useWebSocket } from './useWebSocket';
+export type { UseWebSocketOptions, UseWebSocketReturn, WebSocketStatus } from './useWebSocket.types';

package/dist/hooks/useWebSocket/useWebSocket.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("react");function L(E,M={}){const{autoConnect:O=!0,autoReconnect:T=!0,reconnectAttempts:a=5,reconnectInterval:W=3e3,protocols:N,onOpen:R,onClose:g,onError:C,onMessage:m}=M,[w,o]=e.useState("closed"),[P,J]=e.useState(null),[h,p]=e.useState(null),r=e.useRef(null),l=e.useRef(0),f=e.useRef(null),u=e.useRef(!1),i=e.useRef(R),d=e.useRef(g),S=e.useRef(C),b=e.useRef(m);e.useEffect(()=>{i.current=R,d.current=g,S.current=C,b.current=m},[R,g,C,m]);const s=e.useCallback(()=>{f.current&&(clearTimeout(f.current),f.current=null)},[]),k=e.useCallback(()=>{var c;if(!(typeof window>"u")&&((c=r.current)==null?void 0:c.readyState)!==WebSocket.OPEN){s(),o("connecting"),p(null);try{r.current=new WebSocket(E,N),r.current.onopen=t=>{var n;u.current||(o("open"),l.current=0,(n=i.current)==null||n.call(i,t))},r.current.onclose=t=>{var n;u.current||(o("closed"),(n=d.current)==null||n.call(d,t),T&&l.current<a&&!u.current&&(l.current+=1,f.current=setTimeout(()=>{k()},W)))},r.current.onerror=t=>{var n;u.current||(p(t),(n=S.current)==null||n.call(S,t))},r.current.onmessage=t=>{var n;if(!u.current){try{const I=JSON.parse(t.data);J(I)}catch{J(t.data)}(n=b.current)==null||n.call(b,t)}}}catch(t){o("closed"),p(t)}}},[E,N,T,a,W,s]),j=e.useCallback((c,t)=>{s(),l.current=a,r.current&&(o("closing"),r.current.close(c,t),r.current=null)},[s,a]),y=e.useCallback(c=>{var t;((t=r.current)==null?void 0:t.readyState)===WebSocket.OPEN&&r.current.send(c)},[]),q=e.useCallback(c=>{y(JSON.stringify(c))},[y]),A=e.useCallback(()=>r.current,[]);return e.useEffect(()=>(u.current=!1,O&&k(),()=>{u.current=!0,s(),r.current&&(r.current.close(),r.current=null)}),[O,k,s]),{status:w,isConnected:w==="open",lastMessage:P,error:h,send:y,sendJson:q,connect:k,disconnect:j,getSocket:A}}exports.useWebSocket=L;