@forgedevstack/bear 1.0.7 → 1.0.9

package/dist/hooks/useAnimate.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Animation preset names
+ */
+export type AnimationPreset = 'fadeIn' | 'fadeOut' | 'slideInLeft' | 'slideInRight' | 'slideInUp' | 'slideInDown' | 'slideOutLeft' | 'slideOutRight' | 'slideOutUp' | 'slideOutDown' | 'scaleIn' | 'scaleOut' | 'rotateIn' | 'rotateOut' | 'flipX' | 'flipY' | 'bounceIn' | 'bounceOut' | 'pulse' | 'shake' | 'swing' | 'rubberBand' | 'tada' | 'wobble' | 'jello';
+/**
+ * Keyframe definition
+ */
+export interface AnimationKeyframe {
+    [property: string]: string | number;
+}
+export interface UseAnimateOptions {
+    /** Duration in ms */
+    duration?: number;
+    /** Delay in ms */
+    delay?: number;
+    /** Easing function */
+    easing?: string;
+    /** Number of iterations (Infinity for infinite) */
+    iterations?: number;
+    /** Fill mode */
+    fill?: FillMode;
+    /** Direction */
+    direction?: PlaybackDirection;
+    /** Auto-play on mount */
+    autoPlay?: boolean;
+}
+export interface UseAnimateReturn {
+    /** Ref to attach to the element */
+    ref: React.RefObject<HTMLElement | null>;
+    /** Play the animation */
+    play: (keyframes?: AnimationKeyframe[] | AnimationPreset, options?: UseAnimateOptions) => Animation | undefined;
+    /** Pause the animation */
+    pause: () => void;
+    /** Cancel the animation */
+    cancel: () => void;
+    /** Reverse the animation */
+    reverse: () => void;
+    /** Whether animation is playing */
+    isPlaying: boolean;
+    /** Whether animation is finished */
+    isFinished: boolean;
+}
+/**
+ * useAnimate - Programmatic animation hook using Web Animations API
+ *
+ * @description
+ * Provides a ref-based animation system with built-in presets
+ * and full control over play, pause, cancel, and reverse.
+ *
+ * @example
+ * ```tsx
+ * const { ref, play, isPlaying } = useAnimate({ duration: 500 });
+ *
+ * return (
+ *   <div ref={ref} onClick={() => play('bounceIn')}>
+ *     Animate me!
+ *   </div>
+ * );
+ * ```
+ */
+export declare const useAnimate: (defaultOptions?: UseAnimateOptions) => UseAnimateReturn;

package/dist/hooks/useAnimate.js

@@ -0,0 +1,125 @@
+import { useRef as y, useState as g, useCallback as n, useEffect as x } from "react";
+const f = {
+  fadeIn: [{ opacity: 0 }, { opacity: 1 }],
+  fadeOut: [{ opacity: 1 }, { opacity: 0 }],
+  slideInLeft: [{ transform: "translateX(-100%)", opacity: 0 }, { transform: "translateX(0)", opacity: 1 }],
+  slideInRight: [{ transform: "translateX(100%)", opacity: 0 }, { transform: "translateX(0)", opacity: 1 }],
+  slideInUp: [{ transform: "translateY(100%)", opacity: 0 }, { transform: "translateY(0)", opacity: 1 }],
+  slideInDown: [{ transform: "translateY(-100%)", opacity: 0 }, { transform: "translateY(0)", opacity: 1 }],
+  slideOutLeft: [{ transform: "translateX(0)", opacity: 1 }, { transform: "translateX(-100%)", opacity: 0 }],
+  slideOutRight: [{ transform: "translateX(0)", opacity: 1 }, { transform: "translateX(100%)", opacity: 0 }],
+  slideOutUp: [{ transform: "translateY(0)", opacity: 1 }, { transform: "translateY(-100%)", opacity: 0 }],
+  slideOutDown: [{ transform: "translateY(0)", opacity: 1 }, { transform: "translateY(100%)", opacity: 0 }],
+  scaleIn: [{ transform: "scale(0)", opacity: 0 }, { transform: "scale(1)", opacity: 1 }],
+  scaleOut: [{ transform: "scale(1)", opacity: 1 }, { transform: "scale(0)", opacity: 0 }],
+  rotateIn: [{ transform: "rotate(-180deg) scale(0)", opacity: 0 }, { transform: "rotate(0) scale(1)", opacity: 1 }],
+  rotateOut: [{ transform: "rotate(0) scale(1)", opacity: 1 }, { transform: "rotate(180deg) scale(0)", opacity: 0 }],
+  flipX: [{ transform: "perspective(400px) rotateX(90deg)", opacity: 0 }, { transform: "perspective(400px) rotateX(0)", opacity: 1 }],
+  flipY: [{ transform: "perspective(400px) rotateY(90deg)", opacity: 0 }, { transform: "perspective(400px) rotateY(0)", opacity: 1 }],
+  bounceIn: [
+    { transform: "scale(0.3)", opacity: 0 },
+    { transform: "scale(1.05)" },
+    { transform: "scale(0.9)" },
+    { transform: "scale(1)", opacity: 1 }
+  ],
+  bounceOut: [
+    { transform: "scale(1)", opacity: 1 },
+    { transform: "scale(0.9)" },
+    { transform: "scale(1.05)" },
+    { transform: "scale(0.3)", opacity: 0 }
+  ],
+  pulse: [
+    { transform: "scale(1)" },
+    { transform: "scale(1.05)" },
+    { transform: "scale(1)" }
+  ],
+  shake: [
+    { transform: "translateX(0)" },
+    { transform: "translateX(-10px)" },
+    { transform: "translateX(10px)" },
+    { transform: "translateX(-10px)" },
+    { transform: "translateX(10px)" },
+    { transform: "translateX(0)" }
+  ],
+  swing: [
+    { transform: "rotate(0deg)" },
+    { transform: "rotate(15deg)" },
+    { transform: "rotate(-10deg)" },
+    { transform: "rotate(5deg)" },
+    { transform: "rotate(-5deg)" },
+    { transform: "rotate(0deg)" }
+  ],
+  rubberBand: [
+    { transform: "scale(1)" },
+    { transform: "scaleX(1.25) scaleY(0.75)" },
+    { transform: "scaleX(0.75) scaleY(1.25)" },
+    { transform: "scaleX(1.15) scaleY(0.85)" },
+    { transform: "scaleX(0.95) scaleY(1.05)" },
+    { transform: "scale(1)" }
+  ],
+  tada: [
+    { transform: "scale(1) rotate(0deg)" },
+    { transform: "scale(0.9) rotate(-3deg)" },
+    { transform: "scale(1.1) rotate(3deg)" },
+    { transform: "scale(1.1) rotate(-3deg)" },
+    { transform: "scale(1.1) rotate(3deg)" },
+    { transform: "scale(1) rotate(0deg)" }
+  ],
+  wobble: [
+    { transform: "translateX(0) rotate(0deg)" },
+    { transform: "translateX(-25%) rotate(-5deg)" },
+    { transform: "translateX(20%) rotate(3deg)" },
+    { transform: "translateX(-15%) rotate(-3deg)" },
+    { transform: "translateX(10%) rotate(2deg)" },
+    { transform: "translateX(0) rotate(0deg)" }
+  ],
+  jello: [
+    { transform: "skewX(0deg) skewY(0deg)" },
+    { transform: "skewX(-12.5deg) skewY(-12.5deg)" },
+    { transform: "skewX(6.25deg) skewY(6.25deg)" },
+    { transform: "skewX(-3.125deg) skewY(-3.125deg)" },
+    { transform: "skewX(1.5625deg) skewY(1.5625deg)" },
+    { transform: "skewX(0deg) skewY(0deg)" }
+  ]
+}, v = (c = {}) => {
+  const i = y(null), r = y(null), [u, e] = g(!1), [X, l] = g(!1), m = n(
+    (t, I) => {
+      var d;
+      const p = i.current;
+      if (!p) return;
+      (d = r.current) == null || d.cancel();
+      const a = { ...c, ...I };
+      let s;
+      typeof t == "string" ? s = f[t] ?? f.fadeIn : Array.isArray(t) ? s = t : s = f.fadeIn;
+      const o = p.animate(s, {
+        duration: a.duration ?? 300,
+        delay: a.delay ?? 0,
+        easing: a.easing ?? "ease",
+        iterations: a.iterations ?? 1,
+        fill: a.fill ?? "forwards",
+        direction: a.direction ?? "normal"
+      });
+      return r.current = o, e(!0), l(!1), o.onfinish = () => {
+        e(!1), l(!0);
+      }, o.oncancel = () => {
+        e(!1);
+      }, o;
+    },
+    [c]
+  ), Y = n(() => {
+    var t;
+    (t = r.current) == null || t.pause(), e(!1);
+  }, []), w = n(() => {
+    var t;
+    (t = r.current) == null || t.cancel(), e(!1), l(!1);
+  }, []), k = n(() => {
+    var t;
+    (t = r.current) == null || t.reverse();
+  }, []);
+  return x(() => {
+    c.autoPlay && m();
+  }, []), { ref: i, play: m, pause: Y, cancel: w, reverse: k, isPlaying: u, isFinished: X };
+};
+export {
+  v as useAnimate
+};

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

@@ -0,0 +1,2 @@
+export { useBearComponent, useBC, BearComponentProvider, useBearComponentContext } from './useBearComponent';
+export type { UseBearComponentReturn, BearComponentContextValue } from './useBearComponent.types';

package/dist/hooks/useBearComponent/useBearComponent.cjs

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

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;