@tsdevstack/react-bot-detection 0.1.4

package/dist/hooks/use-bot-detection.js

@@ -0,0 +1,140 @@
+"use client";
+import { useCallback, useEffect, useRef, useState } from "react";
+function useBotDetection() {
+    const [botScore, setBotScore] = useState(0);
+    const [detectionReasons, setDetectionReasons] = useState([]);
+    const [formStartTime] = useState(Date.now());
+    const mouseMovements = useRef([]);
+    const [hasMouseMovement, setHasMouseMovement] = useState(false);
+    const typingPatterns = useRef([]);
+    const lastKeyTime = useRef(0);
+    const [focusEvents, setFocusEvents] = useState(0);
+    const trackMouseMovement = useCallback((e)=>{
+        const movement = {
+            x: e.clientX,
+            y: e.clientY,
+            timestamp: Date.now()
+        };
+        mouseMovements.current.push(movement);
+        setHasMouseMovement(true);
+        if (mouseMovements.current.length > 50) mouseMovements.current.shift();
+    }, []);
+    const trackKeyPress = useCallback((e)=>{
+        const now = Date.now();
+        const timeSinceLastKey = now - lastKeyTime.current;
+        const pattern = {
+            key: e.key,
+            timestamp: now,
+            timeSinceLastKey
+        };
+        typingPatterns.current.push(pattern);
+        lastKeyTime.current = now;
+        if (typingPatterns.current.length > 100) typingPatterns.current.shift();
+    }, []);
+    useEffect(()=>{
+        document.addEventListener('mousemove', trackMouseMovement);
+        document.addEventListener('keydown', trackKeyPress);
+        return ()=>{
+            document.removeEventListener('mousemove', trackMouseMovement);
+            document.removeEventListener('keydown', trackKeyPress);
+        };
+    }, [
+        trackMouseMovement,
+        trackKeyPress
+    ]);
+    const analyzeBehavior = useCallback(()=>{
+        let score = 0;
+        const reasons = [];
+        if (!hasMouseMovement || mouseMovements.current.length < 5) {
+            score += 30;
+            reasons.push('No natural mouse movement detected');
+        } else {
+            const movements = mouseMovements.current.slice(-20);
+            const variations = movements.map((m, i)=>{
+                if (0 === i) return 0;
+                const prev = movements[i - 1];
+                return Math.abs(m.x - prev.x) + Math.abs(m.y - prev.y);
+            });
+            const avgVariation = variations.reduce((a, b)=>a + b, 0) / variations.length;
+            if (avgVariation < 5) {
+                score += 20;
+                reasons.push('Unnatural mouse movement patterns');
+            }
+        }
+        if (typingPatterns.current.length > 10) {
+            const intervals = typingPatterns.current.slice(-20).map((p)=>p.timeSinceLastKey).filter((t)=>t > 0 && t < 1000);
+            if (intervals.length > 5) {
+                const avgInterval = intervals.reduce((a, b)=>a + b, 0) / intervals.length;
+                const variance = intervals.reduce((acc, interval)=>acc + Math.pow(interval - avgInterval, 2), 0) / intervals.length;
+                if (variance < 100) {
+                    score += 15;
+                    reasons.push('Unnaturally consistent typing pattern');
+                }
+                if (avgInterval < 50) {
+                    score += 20;
+                    reasons.push('Superhuman typing speed detected');
+                }
+            }
+        }
+        const currentTime = Date.now();
+        const totalTime = currentTime - formStartTime;
+        if (totalTime < 2000) {
+            score += 40;
+            reasons.push('Form filled too quickly');
+        }
+        if (focusEvents < 2) {
+            score += 15;
+            reasons.push('Insufficient focus interactions');
+        }
+        if ("u" > typeof navigator && true === navigator.webdriver) {
+            score += 25;
+            reasons.push('Automated browser detected');
+        }
+        if ("u" > typeof window && (0 === window.outerWidth || 0 === window.outerHeight)) {
+            score += 35;
+            reasons.push('Headless browser indicators');
+        }
+        return {
+            score,
+            reasons,
+            isBot: score >= 50,
+            stats: {
+                mouseMovements: mouseMovements.current.length,
+                typingEvents: typingPatterns.current.length,
+                focusEvents,
+                timeSpent: Date.now() - formStartTime
+            },
+            honeypotTriggered: false
+        };
+    }, [
+        hasMouseMovement,
+        focusEvents,
+        formStartTime
+    ]);
+    const handleFieldFocus = useCallback(()=>{
+        setFocusEvents((prev)=>prev + 1);
+    }, []);
+    const handleFormSubmit = useCallback(()=>{
+        const result = analyzeBehavior();
+        setBotScore(result.score);
+        setDetectionReasons(result.reasons);
+        return result;
+    }, [
+        analyzeBehavior
+    ]);
+    return {
+        botScore,
+        detectionReasons,
+        isBot: botScore >= 50,
+        analyzeBehavior,
+        handleFieldFocus,
+        handleFormSubmit,
+        stats: {
+            mouseMovements: mouseMovements.current.length,
+            typingEvents: typingPatterns.current.length,
+            focusEvents,
+            timeSpent: Date.now() - formStartTime
+        }
+    };
+}
+export { useBotDetection };

package/dist/hooks/use-bot-detection.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/hooks/use-bot-detection.test.js

@@ -0,0 +1,384 @@
+"use client";
+import { afterEach, beforeEach, describe, expect, it, rs } from "@rstest/core";
+import { act, renderHook } from "@testing-library/react";
+import { useBotDetection } from "./use-bot-detection.js";
+describe('useBotDetection', ()=>{
+    beforeEach(()=>{
+        rs.useFakeTimers();
+    });
+    afterEach(()=>{
+        rs.useRealTimers();
+    });
+    describe('initial state', ()=>{
+        it('should return initial bot score of 0', ()=>{
+            const { result } = renderHook(()=>useBotDetection());
+            expect(result.current.botScore).toBe(0);
+        });
+        it('should return empty detection reasons', ()=>{
+            const { result } = renderHook(()=>useBotDetection());
+            expect(result.current.detectionReasons).toEqual([]);
+        });
+        it('should not flag as bot initially', ()=>{
+            const { result } = renderHook(()=>useBotDetection());
+            expect(result.current.isBot).toBe(false);
+        });
+        it('should return initial stats', ()=>{
+            const { result } = renderHook(()=>useBotDetection());
+            expect(result.current.stats.focusEvents).toBe(0);
+        });
+    });
+    describe('handleFieldFocus', ()=>{
+        it('should increment focus events', ()=>{
+            const { result } = renderHook(()=>useBotDetection());
+            act(()=>{
+                result.current.handleFieldFocus();
+            });
+            expect(result.current.stats.focusEvents).toBe(1);
+        });
+        it('should accumulate focus events', ()=>{
+            const { result } = renderHook(()=>useBotDetection());
+            act(()=>{
+                result.current.handleFieldFocus();
+                result.current.handleFieldFocus();
+                result.current.handleFieldFocus();
+            });
+            expect(result.current.stats.focusEvents).toBe(3);
+        });
+    });
+    describe('analyzeBehavior', ()=>{
+        it('should detect fast form submission', ()=>{
+            const { result } = renderHook(()=>useBotDetection());
+            const analysisResult = result.current.analyzeBehavior();
+            expect(analysisResult.reasons).toContain('Form filled too quickly');
+            expect(analysisResult.score).toBeGreaterThanOrEqual(40);
+        });
+        it('should detect insufficient focus interactions', ()=>{
+            const { result } = renderHook(()=>useBotDetection());
+            rs.advanceTimersByTime(3000);
+            const analysisResult = result.current.analyzeBehavior();
+            expect(analysisResult.reasons).toContain('Insufficient focus interactions');
+        });
+        it('should detect no mouse movement', ()=>{
+            const { result } = renderHook(()=>useBotDetection());
+            rs.advanceTimersByTime(3000);
+            const analysisResult = result.current.analyzeBehavior();
+            expect(analysisResult.reasons).toContain('No natural mouse movement detected');
+        });
+        it('should return isBot true when score >= 50', ()=>{
+            const { result } = renderHook(()=>useBotDetection());
+            const analysisResult = result.current.analyzeBehavior();
+            expect(analysisResult.isBot).toBe(true);
+            expect(analysisResult.score).toBeGreaterThanOrEqual(50);
+        });
+    });
+    describe('handleFormSubmit', ()=>{
+        it('should update botScore state', ()=>{
+            const { result } = renderHook(()=>useBotDetection());
+            act(()=>{
+                result.current.handleFormSubmit();
+            });
+            expect(result.current.botScore).toBeGreaterThan(0);
+        });
+        it('should update detectionReasons state', ()=>{
+            const { result } = renderHook(()=>useBotDetection());
+            act(()=>{
+                result.current.handleFormSubmit();
+            });
+            expect(result.current.detectionReasons.length).toBeGreaterThan(0);
+        });
+        it('should return analysis result', ()=>{
+            const { result } = renderHook(()=>useBotDetection());
+            let submitResult;
+            act(()=>{
+                submitResult = result.current.handleFormSubmit();
+            });
+            expect(submitResult).toHaveProperty('score');
+            expect(submitResult).toHaveProperty('reasons');
+            expect(submitResult).toHaveProperty('isBot');
+            expect(submitResult).toHaveProperty('stats');
+        });
+    });
+    describe('event listeners', ()=>{
+        it('should set up mousemove listener', ()=>{
+            const addEventListenerSpy = rs.spyOn(document, 'addEventListener');
+            renderHook(()=>useBotDetection());
+            expect(addEventListenerSpy).toHaveBeenCalledWith('mousemove', expect.any(Function));
+            addEventListenerSpy.mockRestore();
+        });
+        it('should set up keydown listener', ()=>{
+            const addEventListenerSpy = rs.spyOn(document, 'addEventListener');
+            renderHook(()=>useBotDetection());
+            expect(addEventListenerSpy).toHaveBeenCalledWith('keydown', expect.any(Function));
+            addEventListenerSpy.mockRestore();
+        });
+        it('should clean up event listeners on unmount', ()=>{
+            const removeEventListenerSpy = rs.spyOn(document, 'removeEventListener');
+            const { unmount } = renderHook(()=>useBotDetection());
+            unmount();
+            expect(removeEventListenerSpy).toHaveBeenCalledWith('mousemove', expect.any(Function));
+            expect(removeEventListenerSpy).toHaveBeenCalledWith('keydown', expect.any(Function));
+            removeEventListenerSpy.mockRestore();
+        });
+    });
+    describe('mouse movement tracking', ()=>{
+        it('should track mouse movements and update stats', ()=>{
+            const { result } = renderHook(()=>useBotDetection());
+            for(let i = 0; i < 10; i++)act(()=>{
+                document.dispatchEvent(new MouseEvent('mousemove', {
+                    clientX: 50 * i,
+                    clientY: 30 * i
+                }));
+            });
+            const analysisResult = result.current.analyzeBehavior();
+            expect(analysisResult.stats.mouseMovements).toBe(10);
+        });
+        it('should not flag bot when sufficient natural mouse movement', ()=>{
+            const { result } = renderHook(()=>useBotDetection());
+            for(let i = 0; i < 10; i++)act(()=>{
+                document.dispatchEvent(new MouseEvent('mousemove', {
+                    clientX: 50 * i + 20 * Math.random(),
+                    clientY: 30 * i + 20 * Math.random()
+                }));
+            });
+            rs.advanceTimersByTime(3000);
+            act(()=>{
+                result.current.handleFieldFocus();
+                result.current.handleFieldFocus();
+            });
+            const analysisResult = result.current.analyzeBehavior();
+            expect(analysisResult.reasons).not.toContain('No natural mouse movement detected');
+        });
+        it('should detect unnatural mouse patterns with low variation', ()=>{
+            const { result } = renderHook(()=>useBotDetection());
+            for(let i = 0; i < 10; i++)act(()=>{
+                document.dispatchEvent(new MouseEvent('mousemove', {
+                    clientX: 100 + i,
+                    clientY: 100 + i
+                }));
+            });
+            rs.advanceTimersByTime(3000);
+            const analysisResult = result.current.analyzeBehavior();
+            expect(analysisResult.reasons).toContain('Unnatural mouse movement patterns');
+        });
+        it('should cap mouse movements at 50', ()=>{
+            const { result } = renderHook(()=>useBotDetection());
+            for(let i = 0; i < 60; i++)act(()=>{
+                document.dispatchEvent(new MouseEvent('mousemove', {
+                    clientX: 10 * i,
+                    clientY: 10 * i
+                }));
+            });
+            const analysisResult = result.current.analyzeBehavior();
+            expect(analysisResult.stats.mouseMovements).toBe(50);
+        });
+    });
+    describe('typing pattern tracking', ()=>{
+        it('should track keystrokes and update stats', ()=>{
+            const { result } = renderHook(()=>useBotDetection());
+            for(let i = 0; i < 15; i++){
+                act(()=>{
+                    document.dispatchEvent(new KeyboardEvent('keydown', {
+                        key: 'a'
+                    }));
+                });
+                rs.advanceTimersByTime(100);
+            }
+            const analysisResult = result.current.analyzeBehavior();
+            expect(analysisResult.stats.typingEvents).toBe(15);
+        });
+        it('should detect unnaturally consistent typing', ()=>{
+            const { result } = renderHook(()=>useBotDetection());
+            rs.advanceTimersByTime(3000);
+            for(let i = 0; i < 20; i++){
+                act(()=>{
+                    document.dispatchEvent(new KeyboardEvent('keydown', {
+                        key: 'a'
+                    }));
+                });
+                rs.advanceTimersByTime(50);
+            }
+            for(let i = 0; i < 10; i++)act(()=>{
+                document.dispatchEvent(new MouseEvent('mousemove', {
+                    clientX: 50 * i + 30 * Math.random(),
+                    clientY: 30 * i + 30 * Math.random()
+                }));
+            });
+            act(()=>{
+                result.current.handleFieldFocus();
+                result.current.handleFieldFocus();
+            });
+            const analysisResult = result.current.analyzeBehavior();
+            expect(analysisResult.reasons).toContain('Unnaturally consistent typing pattern');
+        });
+        it('should detect superhuman typing speed', ()=>{
+            const { result } = renderHook(()=>useBotDetection());
+            rs.advanceTimersByTime(3000);
+            for(let i = 0; i < 20; i++){
+                act(()=>{
+                    document.dispatchEvent(new KeyboardEvent('keydown', {
+                        key: 'a'
+                    }));
+                });
+                rs.advanceTimersByTime(30);
+            }
+            for(let i = 0; i < 10; i++)act(()=>{
+                document.dispatchEvent(new MouseEvent('mousemove', {
+                    clientX: 50 * i + 30 * Math.random(),
+                    clientY: 30 * i + 30 * Math.random()
+                }));
+            });
+            act(()=>{
+                result.current.handleFieldFocus();
+                result.current.handleFieldFocus();
+            });
+            const analysisResult = result.current.analyzeBehavior();
+            expect(analysisResult.reasons).toContain('Superhuman typing speed detected');
+        });
+        it('should cap typing patterns at 100', ()=>{
+            const { result } = renderHook(()=>useBotDetection());
+            for(let i = 0; i < 110; i++){
+                act(()=>{
+                    document.dispatchEvent(new KeyboardEvent('keydown', {
+                        key: 'a'
+                    }));
+                });
+                rs.advanceTimersByTime(100);
+            }
+            const analysisResult = result.current.analyzeBehavior();
+            expect(analysisResult.stats.typingEvents).toBe(100);
+        });
+        it('should not flag typing when natural variation exists', ()=>{
+            const { result } = renderHook(()=>useBotDetection());
+            rs.advanceTimersByTime(3000);
+            const intervals = [
+                120,
+                80,
+                150,
+                90,
+                200,
+                100,
+                180,
+                70,
+                130,
+                110,
+                160,
+                95
+            ];
+            for (const interval of intervals){
+                act(()=>{
+                    document.dispatchEvent(new KeyboardEvent('keydown', {
+                        key: 'a'
+                    }));
+                });
+                rs.advanceTimersByTime(interval);
+            }
+            for(let i = 0; i < 10; i++)act(()=>{
+                document.dispatchEvent(new MouseEvent('mousemove', {
+                    clientX: 50 * i + 30 * Math.random(),
+                    clientY: 30 * i + 30 * Math.random()
+                }));
+            });
+            act(()=>{
+                result.current.handleFieldFocus();
+                result.current.handleFieldFocus();
+            });
+            const analysisResult = result.current.analyzeBehavior();
+            expect(analysisResult.reasons).not.toContain('Unnaturally consistent typing pattern');
+            expect(analysisResult.reasons).not.toContain('Superhuman typing speed detected');
+        });
+    });
+    describe('browser detection', ()=>{
+        it('should detect webdriver automation', ()=>{
+            const { result } = renderHook(()=>useBotDetection());
+            const originalNavigator = globalThis.navigator;
+            Object.defineProperty(globalThis, 'navigator', {
+                value: {
+                    ...originalNavigator,
+                    webdriver: true
+                },
+                writable: true,
+                configurable: true
+            });
+            rs.advanceTimersByTime(3000);
+            const analysisResult = result.current.analyzeBehavior();
+            expect(analysisResult.reasons).toContain('Automated browser detected');
+            expect(analysisResult.score).toBeGreaterThanOrEqual(25);
+            Object.defineProperty(globalThis, 'navigator', {
+                value: originalNavigator,
+                writable: true,
+                configurable: true
+            });
+        });
+        it('should detect headless browser indicators', ()=>{
+            const { result } = renderHook(()=>useBotDetection());
+            const originalOuterWidth = window.outerWidth;
+            const originalOuterHeight = window.outerHeight;
+            Object.defineProperty(window, 'outerWidth', {
+                value: 0,
+                writable: true,
+                configurable: true
+            });
+            Object.defineProperty(window, 'outerHeight', {
+                value: 0,
+                writable: true,
+                configurable: true
+            });
+            rs.advanceTimersByTime(3000);
+            const analysisResult = result.current.analyzeBehavior();
+            expect(analysisResult.reasons).toContain('Headless browser indicators');
+            expect(analysisResult.score).toBeGreaterThanOrEqual(35);
+            Object.defineProperty(window, 'outerWidth', {
+                value: originalOuterWidth,
+                writable: true,
+                configurable: true
+            });
+            Object.defineProperty(window, 'outerHeight', {
+                value: originalOuterHeight,
+                writable: true,
+                configurable: true
+            });
+        });
+    });
+    describe('legitimate user behavior', ()=>{
+        it('should pass legitimate user with all natural behaviors', ()=>{
+            const { result } = renderHook(()=>useBotDetection());
+            rs.advanceTimersByTime(5000);
+            for(let i = 0; i < 15; i++)act(()=>{
+                document.dispatchEvent(new MouseEvent('mousemove', {
+                    clientX: 40 * i + 50 * Math.random(),
+                    clientY: 25 * i + 40 * Math.random()
+                }));
+            });
+            const intervals = [
+                120,
+                80,
+                150,
+                90,
+                200,
+                100,
+                180,
+                70,
+                130,
+                110,
+                160,
+                95
+            ];
+            for (const interval of intervals){
+                act(()=>{
+                    document.dispatchEvent(new KeyboardEvent('keydown', {
+                        key: 'a'
+                    }));
+                });
+                rs.advanceTimersByTime(interval);
+            }
+            act(()=>{
+                result.current.handleFieldFocus();
+                result.current.handleFieldFocus();
+                result.current.handleFieldFocus();
+            });
+            const analysisResult = result.current.analyzeBehavior();
+            expect(analysisResult.isBot).toBe(false);
+            expect(analysisResult.score).toBeLessThan(50);
+        });
+    });
+});

package/dist/hooks/use-honeypot.d.ts

@@ -0,0 +1,32 @@
+import React from 'react';
+export interface UseHoneypotReturn {
+    /** Whether a bot has been detected via honeypot */
+    isBotDetected: boolean;
+    /** Score contribution from honeypot (50 if triggered) */
+    botScore: number;
+    /** Callback to mark bot as detected */
+    handleBotDetected: () => void;
+    /** Reset detection state */
+    resetDetection: () => void;
+    /** Pre-configured Honeypot component */
+    HoneypotComponent: () => React.ReactElement;
+}
+/**
+ * Hook for honeypot-based bot detection.
+ *
+ * Provides a hidden form field that bots typically fill out,
+ * allowing detection of automated submissions.
+ *
+ * @example
+ * ```tsx
+ * const { HoneypotComponent, isBotDetected } = useHoneypot();
+ *
+ * return (
+ *   <form>
+ *     <HoneypotComponent />
+ *     {isBotDetected && <p>Bot detected!</p>}
+ *   </form>
+ * );
+ * ```
+ */
+export declare function useHoneypot(): UseHoneypotReturn;

package/dist/hooks/use-honeypot.js

@@ -0,0 +1,29 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { useCallback, useState } from "react";
+import { Honeypot } from "../components/honeypot.js";
+function useHoneypot() {
+    const [isBotDetected, setIsBotDetected] = useState(false);
+    const [botScore, setBotScore] = useState(0);
+    const handleBotDetected = useCallback(()=>{
+        setIsBotDetected(true);
+        setBotScore((prev)=>prev + 50);
+    }, []);
+    const resetDetection = useCallback(()=>{
+        setIsBotDetected(false);
+        setBotScore(0);
+    }, []);
+    const HoneypotComponent = useCallback(()=>/*#__PURE__*/ jsx(Honeypot, {
+            onBotDetected: handleBotDetected
+        }), [
+        handleBotDetected
+    ]);
+    return {
+        isBotDetected,
+        botScore,
+        handleBotDetected,
+        resetDetection,
+        HoneypotComponent
+    };
+}
+export { useHoneypot };

package/dist/hooks/use-honeypot.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/hooks/use-honeypot.test.js

@@ -0,0 +1,78 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { describe, expect, it } from "@rstest/core";
+import { act, render, renderHook } from "@testing-library/react";
+import { useHoneypot } from "./use-honeypot.js";
+describe('useHoneypot', ()=>{
+    describe('initial state', ()=>{
+        it('should not detect bot initially', ()=>{
+            const { result } = renderHook(()=>useHoneypot());
+            expect(result.current.isBotDetected).toBe(false);
+        });
+        it('should have initial bot score of 0', ()=>{
+            const { result } = renderHook(()=>useHoneypot());
+            expect(result.current.botScore).toBe(0);
+        });
+    });
+    describe('handleBotDetected', ()=>{
+        it('should set isBotDetected to true', ()=>{
+            const { result } = renderHook(()=>useHoneypot());
+            act(()=>{
+                result.current.handleBotDetected();
+            });
+            expect(result.current.isBotDetected).toBe(true);
+        });
+        it('should add 50 to bot score', ()=>{
+            const { result } = renderHook(()=>useHoneypot());
+            act(()=>{
+                result.current.handleBotDetected();
+            });
+            expect(result.current.botScore).toBe(50);
+        });
+        it('should accumulate bot score on multiple calls', ()=>{
+            const { result } = renderHook(()=>useHoneypot());
+            act(()=>{
+                result.current.handleBotDetected();
+                result.current.handleBotDetected();
+            });
+            expect(result.current.botScore).toBe(100);
+        });
+    });
+    describe('resetDetection', ()=>{
+        it('should reset isBotDetected to false', ()=>{
+            const { result } = renderHook(()=>useHoneypot());
+            act(()=>{
+                result.current.handleBotDetected();
+            });
+            expect(result.current.isBotDetected).toBe(true);
+            act(()=>{
+                result.current.resetDetection();
+            });
+            expect(result.current.isBotDetected).toBe(false);
+        });
+        it('should reset bot score to 0', ()=>{
+            const { result } = renderHook(()=>useHoneypot());
+            act(()=>{
+                result.current.handleBotDetected();
+            });
+            expect(result.current.botScore).toBe(50);
+            act(()=>{
+                result.current.resetDetection();
+            });
+            expect(result.current.botScore).toBe(0);
+        });
+    });
+    describe('HoneypotComponent', ()=>{
+        it('should render a component', ()=>{
+            const { result } = renderHook(()=>useHoneypot());
+            const { container } = render(/*#__PURE__*/ jsx(result.current.HoneypotComponent, {}));
+            expect(container.firstChild).not.toBeNull();
+        });
+        it('should render honeypot fields with aria-hidden', ()=>{
+            const { result } = renderHook(()=>useHoneypot());
+            render(/*#__PURE__*/ jsx(result.current.HoneypotComponent, {}));
+            const hiddenWrapper = document.querySelector('[aria-hidden="true"]');
+            expect(hiddenWrapper).not.toBeNull();
+        });
+    });
+});

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export type { BotDetectionResult, BotDetectionStats, ButtonComponentProps, } from './types';
+export { useBotDetection } from './hooks';
+export type { UseBotDetectionReturn } from './hooks';
+export { useHoneypot } from './hooks';
+export type { UseHoneypotReturn } from './hooks';
+export { Honeypot } from './components';
+export type { HoneypotProps } from './components';
+export { BotProtectedForm } from './components';
+export type { BotProtectedFormProps } from './components';

package/dist/index.js

@@ -0,0 +1,3 @@
+import { useBotDetection, useHoneypot } from "./hooks/index.js";
+import { BotProtectedForm, Honeypot } from "./components/index.js";
+export { BotProtectedForm, Honeypot, useBotDetection, useHoneypot };