@forgedevstack/bear 1.0.6 → 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/useDragDrop/index.d.ts

@@ -0,0 +1,2 @@
+export { useDragDrop } from './useDragDrop';
+export type { UseDragDropOptions, UseDragDropReturn, DragDropId } from './useDragDrop.types';

package/dist/hooks/useDragDrop/useDragDrop.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const n=require("react"),A="bear-dnd",E=(v={})=>{const{onDragStart:o,onDragEnd:c,onDrop:g,onDragOver:d,onDragLeave:f,disabled:a=!1,dragType:D=A}=v,[I,i]=n.useState(!1),[S,T]=n.useState(null),[y,p]=n.useState(null),s=n.useRef(null),P=n.useCallback((e,u,l)=>({draggable:!a,onDragStart:r=>{a||(r.dataTransfer.setData(D,String(e)),r.dataTransfer.effectAllowed="move",s.current={id:e,item:u,index:l},T(e),i(!0),o==null||o(e,u,l))},onDragEnd:r=>{a||(s.current=null,T(null),p(null),i(!1),c==null||c(e,u,l))},"data-drag-id":e}),[a,D,o,c]),R=n.useCallback((e,u,l)=>({onDragOver:r=>{var b;if(a||!r.dataTransfer.types.includes(D))return;r.preventDefault(),r.dataTransfer.dropEffect="move";const t=(b=s.current)==null?void 0:b.id;t!=null&&t!==e&&(p(e),d==null||d(t,e))},onDragLeave:r=>{r.currentTarget.contains(r.relatedTarget)||(p(null),f==null||f(e))},onDrop:r=>{if(a)return;r.preventDefault(),p(null);const t=s.current;!t||t.id===e||g==null||g(t.id,e,t.index,l,t.item,u)},"data-drop-id":e}),[a,D,d,f,g]);return{isDragging:I,draggedId:S,dragOverId:y,getDragProps:P,getDropProps:R,dragDataRef:s}};exports.useDragDrop=E;

package/dist/hooks/useDragDrop/useDragDrop.d.ts

@@ -0,0 +1,22 @@
+import { UseDragDropOptions, UseDragDropReturn } from './useDragDrop.types';
+/**
+ * useDragDrop - Hook for HTML5 drag and drop
+ *
+ * @example
+ * ```tsx
+ * const { getDragProps, getDropProps, isDragging } = useDragDrop({
+ *   onDrop: (sourceId, targetId) => reorder(sourceId, targetId),
+ * });
+ *
+ * return (
+ *   <div {...getDropProps('col-1', col, 0)}>
+ *     {items.map((item, i) => (
+ *       <div key={item.id} {...getDragProps(item.id, item, i)}>
+ *         {item.label}
+ *       </div>
+ *     ))}
+ *   </div>
+ * );
+ * ```
+ */
+export declare const useDragDrop: <T = unknown>(options?: UseDragDropOptions<T>) => UseDragDropReturn<T>;

package/dist/hooks/useDragDrop/useDragDrop.js

@@ -0,0 +1,56 @@
+import { useState as p, useRef as _, useCallback as I } from "react";
+const y = "bear-dnd", S = (b = {}) => {
+  const {
+    onDragStart: u,
+    onDragEnd: o,
+    onDrop: g,
+    onDragOver: f,
+    onDragLeave: c,
+    disabled: a = !1,
+    dragType: d = y
+  } = b, [m, T] = p(!1), [A, i] = p(null), [E, D] = p(null), n = _(null), P = I(
+    (r, s, l) => ({
+      draggable: !a,
+      onDragStart: (e) => {
+        a || (e.dataTransfer.setData(d, String(r)), e.dataTransfer.effectAllowed = "move", n.current = { id: r, item: s, index: l }, i(r), T(!0), u == null || u(r, s, l));
+      },
+      onDragEnd: (e) => {
+        a || (n.current = null, i(null), D(null), T(!1), o == null || o(r, s, l));
+      },
+      "data-drag-id": r
+    }),
+    [a, d, u, o]
+  ), R = I(
+    (r, s, l) => ({
+      onDragOver: (e) => {
+        var v;
+        if (a || !e.dataTransfer.types.includes(d)) return;
+        e.preventDefault(), e.dataTransfer.dropEffect = "move";
+        const t = (v = n.current) == null ? void 0 : v.id;
+        t != null && t !== r && (D(r), f == null || f(t, r));
+      },
+      onDragLeave: (e) => {
+        e.currentTarget.contains(e.relatedTarget) || (D(null), c == null || c(r));
+      },
+      onDrop: (e) => {
+        if (a) return;
+        e.preventDefault(), D(null);
+        const t = n.current;
+        !t || t.id === r || g == null || g(t.id, r, t.index, l, t.item, s);
+      },
+      "data-drop-id": r
+    }),
+    [a, d, f, c, g]
+  );
+  return {
+    isDragging: m,
+    draggedId: A,
+    dragOverId: E,
+    getDragProps: P,
+    getDropProps: R,
+    dragDataRef: n
+  };
+};
+export {
+  S as useDragDrop
+};

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

@@ -0,0 +1,55 @@
+import { MutableRefObject } from 'react';
+/**
+ * Drag and drop item identifier
+ */
+export type DragDropId = string | number;
+/**
+ * UseDragDrop options
+ */
+export interface UseDragDropOptions<T = unknown> {
+    /** Callback when drag starts */
+    onDragStart?: (id: DragDropId, item: T, index: number) => void;
+    /** Callback when drag ends */
+    onDragEnd?: (id: DragDropId, item: T, index: number) => void;
+    /** Callback when item is dropped on target */
+    onDrop?: (sourceId: DragDropId, targetId: DragDropId, sourceIndex: number, targetIndex: number, sourceItem: T, targetItem: T) => void;
+    /** Callback when hovering over drop target */
+    onDragOver?: (sourceId: DragDropId, targetId: DragDropId) => void;
+    /** Callback when leaving drop target */
+    onDragLeave?: (targetId: DragDropId) => void;
+    /** Whether dragging is disabled */
+    disabled?: boolean;
+    /** HTML5 drag type (default: 'bear-dnd') */
+    dragType?: string;
+}
+/**
+ * UseDragDrop return value
+ */
+export interface UseDragDropReturn<T = unknown> {
+    /** Whether an item is currently being dragged */
+    isDragging: boolean;
+    /** ID of the item being dragged */
+    draggedId: DragDropId | null;
+    /** ID of the current drop target hovered */
+    dragOverId: DragDropId | null;
+    /** Props to spread on draggable element */
+    getDragProps: (id: DragDropId, item: T, index: number) => {
+        draggable: boolean;
+        onDragStart: (e: React.DragEvent) => void;
+        onDragEnd: (e: React.DragEvent) => void;
+        'data-drag-id': DragDropId;
+    };
+    /** Props to spread on drop target element */
+    getDropProps: (id: DragDropId, item: T, index: number) => {
+        onDragOver: (e: React.DragEvent) => void;
+        onDragLeave: (e: React.DragEvent) => void;
+        onDrop: (e: React.DragEvent) => void;
+        'data-drop-id': DragDropId;
+    };
+    /** Ref to store dragged item data (for cross-component) */
+    dragDataRef: MutableRefObject<{
+        id: DragDropId;
+        item: T;
+        index: number;
+    } | null>;
+}

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/useLazyLoad/index.d.ts

@@ -0,0 +1,2 @@
+export { useLazyLoad } from './useLazyLoad';
+export type { UseLazyLoadOptions, UseLazyLoadReturn } from './useLazyLoad.types';

package/dist/hooks/useLazyLoad/useLazyLoad.cjs

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

package/dist/hooks/useLazyLoad/useLazyLoad.d.ts

@@ -0,0 +1,26 @@
+import { UseLazyLoadOptions, UseLazyLoadReturn } from './useLazyLoad.types';
+/**
+ * useLazyLoad - Lazy load content when it enters the viewport.
+ * Useful for infinite scroll, lazy images, or deferring heavy renders.
+ *
+ * @example
+ * ```tsx
+ * const { ref, hasBeenViewed } = useLazyLoad();
+ *
+ * return (
+ *   <div ref={ref}>
+ *     {hasBeenViewed ? <HeavyComponent /> : <Skeleton />}
+ *   </div>
+ * );
+ * ```
+ *
+ * @example
+ * ```tsx
+ * const { ref, isInView } = useLazyLoad({ once: false });
+ * useEffect(() => {
+ *   if (isInView) loadMore();
+ * }, [isInView]);
+ * return <div ref={ref}>Load more trigger</div>;
+ * ```
+ */
+export declare const useLazyLoad: <T extends HTMLElement = HTMLDivElement>(options?: UseLazyLoadOptions) => UseLazyLoadReturn<T>;

package/dist/hooks/useLazyLoad/useLazyLoad.js

@@ -0,0 +1,27 @@
+import { useRef as I, useState as u, useEffect as b } from "react";
+const p = (f = {}) => {
+  const {
+    rootMargin: t = "100px",
+    threshold: r = 0,
+    once: o = !0,
+    enabled: i = !0
+  } = f, e = I(null), [a, d] = u(!1), [l, w] = u(!1);
+  return b(() => {
+    if (!i || !e.current || typeof IntersectionObserver > "u") return;
+    const s = new IntersectionObserver(
+      ([n]) => {
+        const c = (n == null ? void 0 : n.isIntersecting) ?? !1;
+        d(c), c && (w(!0), o && s.disconnect());
+      },
+      { rootMargin: t, threshold: r }
+    );
+    return s.observe(e.current), () => s.disconnect();
+  }, [i, t, r, o]), {
+    ref: e,
+    isInView: a,
+    hasBeenViewed: l
+  };
+};
+export {
+  p as useLazyLoad
+};

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

@@ -0,0 +1,25 @@
+import { RefObject } from 'react';
+/**
+ * useLazyLoad options
+ */
+export interface UseLazyLoadOptions {
+    /** Root margin for IntersectionObserver (e.g. '100px' to trigger before visible) */
+    rootMargin?: string;
+    /** Threshold 0–1 for how much must be visible */
+    threshold?: number;
+    /** Once in view, stay loaded (default: true) */
+    once?: boolean;
+    /** Enable observer */
+    enabled?: boolean;
+}
+/**
+ * useLazyLoad return value
+ */
+export interface UseLazyLoadReturn<T extends HTMLElement> {
+    /** Ref to attach to the element to observe */
+    ref: RefObject<T | null>;
+    /** Whether element is currently in viewport */
+    isInView: boolean;
+    /** Whether element has ever been in view (stays true once loaded) */
+    hasBeenViewed: boolean;
+}

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;