@arfuhad/react-native-smart-camera 0.1.2 → 0.1.5

package/build/detection/staticImageDetector.js

@@ -1,4 +1,3 @@
-import SmartCameraModule from '../SmartCameraModule';
 /**
  * Default options for static image face detection
  */
@@ -13,36 +12,33 @@ const DEFAULT_OPTIONS = {
 /**
  * Detect faces in a static image
  *
+ * NOTE: Static image detection is currently not supported in the frame processor-only version.
+ * This feature requires native module implementation.
+ * For real-time face detection, use the `detectFaces` function with VisionCamera frame processor.
+ *
  * @param options - Image source and detection options
  * @returns Promise resolving to array of detected faces
  *
  * @example
  * ```tsx
- * // Using require
- * const faces = await detectFacesInImage({
- *   image: require('./photo.jpg'),
- *   performanceMode: 'accurate',
- *   landmarkMode: 'all',
- * });
+ * // This feature is not yet implemented
+ * // For real-time detection, use:
+ * import { detectFaces } from '@arfuhad/react-native-smart-camera';
  *
- * // Using URI
- * const faces = await detectFacesInImage({
- *   image: { uri: 'https://example.com/photo.jpg' },
- *   classificationMode: 'all',
- * });
+ * const frameProcessor = useFrameProcessor((frame) => {
+ *   'worklet';
+ *   const faces = detectFaces(frame);
+ * }, []);
  * ```
  */
 export async function detectFacesInImage(options) {
-    const mergedOptions = {
-        ...DEFAULT_OPTIONS,
-        ...options,
-    };
-    try {
-        return await SmartCameraModule.detectFacesInImage(mergedOptions);
-    }
-    catch (error) {
-        console.error('[SmartCamera] Error detecting faces in image:', error);
-        throw error;
-    }
+    const mergedOptions = Object.assign(Object.assign({}, DEFAULT_OPTIONS), options);
+    // TODO: Implement static image detection
+    // This requires either:
+    // 1. A separate native module for static image processing
+    // 2. Using react-native-ml-kit directly
+    console.warn('[SmartCamera] Static image detection is not yet implemented. ' +
+        'For real-time face detection, use the detectFaces function with VisionCamera frame processor.');
+    return [];
 }
 //# sourceMappingURL=staticImageDetector.js.map

package/build/detection/staticImageDetector.js.map

@@ -1 +1 @@
-{"version":3,"file":"staticImageDetector.js","sourceRoot":"","sources":["../../src/detection/staticImageDetector.ts"],"names":[],"mappings":"AAAA,OAAO,iBAAiB,MAAM,sBAAsB,CAAC;AAGrD;;GAEG;AACH,MAAM,eAAe,GAAgC;IACnD,eAAe,EAAE,UAAU;IAC3B,YAAY,EAAE,MAAM;IACpB,WAAW,EAAE,MAAM;IACnB,kBAAkB,EAAE,MAAM;IAC1B,WAAW,EAAE,IAAI;IACjB,eAAe,EAAE,KAAK;CACvB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,CAAC,KAAK,UAAU,kBAAkB,CAAC,OAA2B;IAClE,MAAM,aAAa,GAAuB;QACxC,GAAG,eAAe;QAClB,GAAG,OAAO;KACX,CAAC;IAEF,IAAI,CAAC;QACH,OAAO,MAAM,iBAAiB,CAAC,kBAAkB,CAAC,aAAa,CAAC,CAAC;IACnE,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,OAAO,CAAC,KAAK,CAAC,+CAA+C,EAAE,KAAK,CAAC,CAAC;QACtE,MAAM,KAAK,CAAC;IACd,CAAC;AACH,CAAC","sourcesContent":["import SmartCameraModule from '../SmartCameraModule';\nimport type { Face, StaticImageOptions } from '../types';\n\n/**\n * Default options for static image face detection\n */\nconst DEFAULT_OPTIONS: Partial<StaticImageOptions> = {\n  performanceMode: 'accurate',\n  landmarkMode: 'none',\n  contourMode: 'none',\n  classificationMode: 'none',\n  minFaceSize: 0.15,\n  trackingEnabled: false,\n};\n\n/**\n * Detect faces in a static image\n * \n * @param options - Image source and detection options\n * @returns Promise resolving to array of detected faces\n * \n * @example\n * ```tsx\n * // Using require\n * const faces = await detectFacesInImage({\n *   image: require('./photo.jpg'),\n *   performanceMode: 'accurate',\n *   landmarkMode: 'all',\n * });\n * \n * // Using URI\n * const faces = await detectFacesInImage({\n *   image: { uri: 'https://example.com/photo.jpg' },\n *   classificationMode: 'all',\n * });\n * ```\n */\nexport async function detectFacesInImage(options: StaticImageOptions): Promise<Face[]> {\n  const mergedOptions: StaticImageOptions = {\n    ...DEFAULT_OPTIONS,\n    ...options,\n  };\n\n  try {\n    return await SmartCameraModule.detectFacesInImage(mergedOptions);\n  } catch (error) {\n    console.error('[SmartCamera] Error detecting faces in image:', error);\n    throw error;\n  }\n}\n\n"]}
+{"version":3,"file":"staticImageDetector.js","sourceRoot":"","sources":["../../src/detection/staticImageDetector.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,MAAM,eAAe,GAAgC;IACnD,eAAe,EAAE,UAAU;IAC3B,YAAY,EAAE,MAAM;IACpB,WAAW,EAAE,MAAM;IACnB,kBAAkB,EAAE,MAAM;IAC1B,WAAW,EAAE,IAAI;IACjB,eAAe,EAAE,KAAK;CACvB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,CAAC,KAAK,UAAU,kBAAkB,CAAC,OAA2B;IAClE,MAAM,aAAa,mCACd,eAAe,GACf,OAAO,CACX,CAAC;IAEF,yCAAyC;IACzC,wBAAwB;IACxB,0DAA0D;IAC1D,wCAAwC;IACxC,OAAO,CAAC,IAAI,CACV,+DAA+D;QAC/D,+FAA+F,CAChG,CAAC;IAEF,OAAO,EAAE,CAAC;AACZ,CAAC"}

package/build/hooks/index.d.ts

@@ -1,5 +1,11 @@
 export { useSmartCamera, getAvailableCameras } from './useSmartCamera';
 export { useFaceDetection, type UseFaceDetectionOptions } from './useFaceDetection';
+export { useFaceDetector, useFaceDetectorWithCallback, type UseFaceDetectorOptions, type UseFaceDetectorResult, type UseFaceDetectorWithCallbackOptions, type FaceDetectionCallback, } from './useFaceDetector';
 export { useBlinkDetection, type UseBlinkDetectionOptions } from './useBlinkDetection';
+export { useWebRTC } from './useWebRTC';
+export type { UseWebRTCOptions, UseWebRTCResult } from './useWebRTC';
+export { useWebRTCWithDetection } from './useWebRTCWithDetection';
+export type { UseWebRTCWithDetectionOptions } from './useWebRTCWithDetection';
+export type { UseWebRTCWithDetectionResult } from './useWebRTCWithDetection';
 export { useSmartCameraWebRTC, type UseSmartCameraWebRTCOptions } from './useSmartCameraWebRTC';
 //# sourceMappingURL=index.d.ts.map

package/build/hooks/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/hooks/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AACvE,OAAO,EAAE,gBAAgB,EAAE,KAAK,uBAAuB,EAAE,MAAM,oBAAoB,CAAC;AACpF,OAAO,EAAE,iBAAiB,EAAE,KAAK,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AACvF,OAAO,EAAE,oBAAoB,EAAE,KAAK,2BAA2B,EAAE,MAAM,wBAAwB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/hooks/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAGvE,OAAO,EAAE,gBAAgB,EAAE,KAAK,uBAAuB,EAAE,MAAM,oBAAoB,CAAC;AACpF,OAAO,EACL,eAAe,EACf,2BAA2B,EAC3B,KAAK,sBAAsB,EAC3B,KAAK,qBAAqB,EAC1B,KAAK,kCAAkC,EACvC,KAAK,qBAAqB,GAC3B,MAAM,mBAAmB,CAAC;AAG3B,OAAO,EAAE,iBAAiB,EAAE,KAAK,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAGvF,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,YAAY,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AACrE,OAAO,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAClE,YAAY,EAAE,6BAA6B,EAAE,MAAM,0BAA0B,CAAC;AAC9E,YAAY,EAAE,4BAA4B,EAAE,MAAM,0BAA0B,CAAC;AAG7E,OAAO,EAAE,oBAAoB,EAAE,KAAK,2BAA2B,EAAE,MAAM,wBAAwB,CAAC"}

package/build/hooks/index.js

@@ -1,5 +1,13 @@
+// Camera management
 export { useSmartCamera, getAvailableCameras } from './useSmartCamera';
+// Face detection
 export { useFaceDetection } from './useFaceDetection';
+export { useFaceDetector, useFaceDetectorWithCallback, } from './useFaceDetector';
+// Eye/Blink detection
 export { useBlinkDetection } from './useBlinkDetection';
+// WebRTC video calling
+export { useWebRTC } from './useWebRTC';
+export { useWebRTCWithDetection } from './useWebRTCWithDetection';
+// Legacy WebRTC hook (deprecated, use useWebRTC instead)
 export { useSmartCameraWebRTC } from './useSmartCameraWebRTC';
 //# sourceMappingURL=index.js.map

package/build/hooks/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/hooks/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AACvE,OAAO,EAAE,gBAAgB,EAAgC,MAAM,oBAAoB,CAAC;AACpF,OAAO,EAAE,iBAAiB,EAAiC,MAAM,qBAAqB,CAAC;AACvF,OAAO,EAAE,oBAAoB,EAAoC,MAAM,wBAAwB,CAAC","sourcesContent":["export { useSmartCamera, getAvailableCameras } from './useSmartCamera';\nexport { useFaceDetection, type UseFaceDetectionOptions } from './useFaceDetection';\nexport { useBlinkDetection, type UseBlinkDetectionOptions } from './useBlinkDetection';\nexport { useSmartCameraWebRTC, type UseSmartCameraWebRTCOptions } from './useSmartCameraWebRTC';\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/hooks/index.ts"],"names":[],"mappings":"AAAA,oBAAoB;AACpB,OAAO,EAAE,cAAc,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAEvE,iBAAiB;AACjB,OAAO,EAAE,gBAAgB,EAAgC,MAAM,oBAAoB,CAAC;AACpF,OAAO,EACL,eAAe,EACf,2BAA2B,GAK5B,MAAM,mBAAmB,CAAC;AAE3B,sBAAsB;AACtB,OAAO,EAAE,iBAAiB,EAAiC,MAAM,qBAAqB,CAAC;AAEvF,uBAAuB;AACvB,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAExC,OAAO,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAIlE,yDAAyD;AACzD,OAAO,EAAE,oBAAoB,EAAoC,MAAM,wBAAwB,CAAC"}

package/build/hooks/useBlinkDetection.d.ts

@@ -1,35 +1,46 @@
-import type { BlinkEvent, UseBlinkDetectionResult } from '../types';
+import type { EyeStatusResult, UseBlinkDetectionResult } from '../types';
 /**
  * Options for useBlinkDetection hook
  */
 export interface UseBlinkDetectionOptions {
-    /** Whether blink detection is enabled. Default: true */
+    /** Whether eye tracking is enabled. Default: true */
     enabled?: boolean;
-    /** Minimum time between blinks in milliseconds. Default: 300 */
-    debounceMs?: number;
-    /** Callback when a blink is detected */
-    onBlink?: (event: BlinkEvent) => void;
+    /** Threshold below which an eye is considered closed (0-1). Default: 0.5 */
+    eyeClosedThreshold?: number;
+    /** Callback when eye status changes */
+    onEyeStatusChange?: (status: EyeStatusResult) => void;
 }
 /**
- * Hook for managing blink detection state
+ * Hook for tracking eye status from detected faces
  *
- * @param options - Blink detection options
- * @returns Blink detection state and controls
+ * This hook provides real-time eye open/closed status based on face detection results.
+ * The user can set their own threshold for determining when an eye is considered closed.
+ *
+ * @param options - Eye tracking options
+ * @returns Eye status and controls
  *
  * @example
  * ```tsx
- * function BlinkCounter() {
- *   const { lastBlink, blinkCount, resetCount } = useBlinkDetection({
- *     debounceMs: 300,
- *     onBlink: (event) => {
- *       console.log('Blink detected at', event.timestamp);
+ * function EyeTracker() {
+ *   const { eyeStatus, processEyeStatus } = useBlinkDetection({
+ *     eyeClosedThreshold: 0.3, // Consider eye closed when probability < 0.3
+ *     onEyeStatusChange: (status) => {
+ *       // Handle blink detection yourself based on status
+ *       if (status.leftEye.isClosed && status.rightEye.isClosed) {
+ *         console.log('Both eyes closed!');
+ *       }
  *     },
  *   });
  *
+ *   // In your face detection callback:
+ *   const handleFaces = (faces: Face[]) => {
+ *     processEyeStatus(faces);
+ *   };
+ *
  *   return (
  *     <View>
- *       <Text>Blinks: {blinkCount}</Text>
- *       <Button onPress={resetCount} title="Reset" />
+ *       <Text>Left Eye: {eyeStatus?.leftEye.openProbability.toFixed(2)}</Text>
+ *       <Text>Right Eye: {eyeStatus?.rightEye.openProbability.toFixed(2)}</Text>
  *     </View>
  *   );
  * }

package/build/hooks/useBlinkDetection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useBlinkDetection.d.ts","sourceRoot":"","sources":["../../src/hooks/useBlinkDetection.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,uBAAuB,EAAE,MAAM,UAAU,CAAC;AAEpE;;GAEG;AACH,MAAM,WAAW,wBAAwB;IACvC,wDAAwD;IACxD,OAAO,CAAC,EAAE,OAAO,CAAC;IAElB,gEAAgE;IAChE,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB,wCAAwC;IACxC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,CAAC;CACvC;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,GAAE,wBAA6B,GACrC,uBAAuB,CA+CzB"}
+{"version":3,"file":"useBlinkDetection.d.ts","sourceRoot":"","sources":["../../src/hooks/useBlinkDetection.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAQ,eAAe,EAAE,uBAAuB,EAAE,MAAM,UAAU,CAAC;AAE/E;;GAEG;AACH,MAAM,WAAW,wBAAwB;IACvC,qDAAqD;IACrD,OAAO,CAAC,EAAE,OAAO,CAAC;IAElB,4EAA4E;IAC5E,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAE5B,uCAAuC;IACvC,iBAAiB,CAAC,EAAE,CAAC,MAAM,EAAE,eAAe,KAAK,IAAI,CAAC;CACvD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,GAAE,wBAA6B,GACrC,uBAAuB,CAsEzB"}

package/build/hooks/useBlinkDetection.js

@@ -1,67 +1,93 @@
 import { useState, useCallback, useRef, useEffect } from 'react';
 /**
- * Hook for managing blink detection state
+ * Hook for tracking eye status from detected faces
  *
- * @param options - Blink detection options
- * @returns Blink detection state and controls
+ * This hook provides real-time eye open/closed status based on face detection results.
+ * The user can set their own threshold for determining when an eye is considered closed.
+ *
+ * @param options - Eye tracking options
+ * @returns Eye status and controls
  *
  * @example
  * ```tsx
- * function BlinkCounter() {
- *   const { lastBlink, blinkCount, resetCount } = useBlinkDetection({
- *     debounceMs: 300,
- *     onBlink: (event) => {
- *       console.log('Blink detected at', event.timestamp);
+ * function EyeTracker() {
+ *   const { eyeStatus, processEyeStatus } = useBlinkDetection({
+ *     eyeClosedThreshold: 0.3, // Consider eye closed when probability < 0.3
+ *     onEyeStatusChange: (status) => {
+ *       // Handle blink detection yourself based on status
+ *       if (status.leftEye.isClosed && status.rightEye.isClosed) {
+ *         console.log('Both eyes closed!');
+ *       }
  *     },
  *   });
  *
+ *   // In your face detection callback:
+ *   const handleFaces = (faces: Face[]) => {
+ *     processEyeStatus(faces);
+ *   };
+ *
  *   return (
  *     <View>
- *       <Text>Blinks: {blinkCount}</Text>
- *       <Button onPress={resetCount} title="Reset" />
+ *       <Text>Left Eye: {eyeStatus?.leftEye.openProbability.toFixed(2)}</Text>
+ *       <Text>Right Eye: {eyeStatus?.rightEye.openProbability.toFixed(2)}</Text>
  *     </View>
  *   );
  * }
  * ```
  */
 export function useBlinkDetection(options = {}) {
-    const { enabled = true, debounceMs = 300, onBlink } = options;
-    const [lastBlink, setLastBlink] = useState(null);
-    const [blinkCount, setBlinkCount] = useState(0);
-    const callbackRef = useRef(onBlink);
-    const lastBlinkTimeRef = useRef(0);
+    const { enabled = true, eyeClosedThreshold = 0.5, onEyeStatusChange } = options;
+    const [eyeStatus, setEyeStatus] = useState(null);
+    const callbackRef = useRef(onEyeStatusChange);
     // Keep callback ref updated
     useEffect(() => {
-        callbackRef.current = onBlink;
-    }, [onBlink]);
-    // Handle blink event (called from frame processor)
-    const handleBlink = useCallback((event) => {
-        const now = Date.now();
-        // Apply debounce
-        if (now - lastBlinkTimeRef.current < debounceMs) {
+        callbackRef.current = onEyeStatusChange;
+    }, [onEyeStatusChange]);
+    // Process faces to get eye status (call this from JS thread with detected faces)
+    const processEyeStatus = useCallback((faces) => {
+        var _a;
+        if (!enabled || faces.length === 0) {
             return;
         }
-        lastBlinkTimeRef.current = now;
-        setLastBlink(event);
-        setBlinkCount((prev) => prev + 1);
-        callbackRef.current?.(event);
-    }, [debounceMs]);
-    // Reset blink count
-    const resetCount = useCallback(() => {
-        setBlinkCount(0);
-        setLastBlink(null);
-        lastBlinkTimeRef.current = 0;
+        // Use the first face (most prominent)
+        const face = faces[0];
+        // Ensure we have eye classification data
+        if (face.leftEyeOpenProbability === undefined ||
+            face.rightEyeOpenProbability === undefined) {
+            return;
+        }
+        const leftOpenProbability = face.leftEyeOpenProbability;
+        const rightOpenProbability = face.rightEyeOpenProbability;
+        const now = Date.now();
+        const status = {
+            leftEye: {
+                openProbability: leftOpenProbability,
+                isClosed: leftOpenProbability < eyeClosedThreshold,
+            },
+            rightEye: {
+                openProbability: rightOpenProbability,
+                isClosed: rightOpenProbability < eyeClosedThreshold,
+            },
+            faceId: face.trackingId,
+            timestamp: now,
+        };
+        setEyeStatus(status);
+        (_a = callbackRef.current) === null || _a === void 0 ? void 0 : _a.call(callbackRef, status);
+    }, [enabled, eyeClosedThreshold]);
+    // Reset eye status
+    const reset = useCallback(() => {
+        setEyeStatus(null);
     }, []);
     // Reset on disable
     useEffect(() => {
         if (!enabled) {
-            resetCount();
+            reset();
         }
-    }, [enabled, resetCount]);
+    }, [enabled, reset]);
     return {
-        lastBlink,
-        blinkCount,
-        resetCount,
+        eyeStatus,
+        processEyeStatus,
+        reset,
     };
 }
 //# sourceMappingURL=useBlinkDetection.js.map

package/build/hooks/useBlinkDetection.js.map

@@ -1 +1 @@
-{"version":3,"file":"useBlinkDetection.js","sourceRoot":"","sources":["../../src/hooks/useBlinkDetection.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAiBjE;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,UAAU,iBAAiB,CAC/B,UAAoC,EAAE;IAEtC,MAAM,EAAE,OAAO,GAAG,IAAI,EAAE,UAAU,GAAG,GAAG,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC;IAE9D,MAAM,CAAC,SAAS,EAAE,YAAY,CAAC,GAAG,QAAQ,CAAoB,IAAI,CAAC,CAAC;IACpE,MAAM,CAAC,UAAU,EAAE,aAAa,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;IAChD,MAAM,WAAW,GAAG,MAAM,CAAC,OAAO,CAAC,CAAC;IACpC,MAAM,gBAAgB,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;IAEnC,4BAA4B;IAC5B,SAAS,CAAC,GAAG,EAAE;QACb,WAAW,CAAC,OAAO,GAAG,OAAO,CAAC;IAChC,CAAC,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC;IAEd,mDAAmD;IACnD,MAAM,WAAW,GAAG,WAAW,CAAC,CAAC,KAAiB,EAAE,EAAE;QACpD,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QAEvB,iBAAiB;QACjB,IAAI,GAAG,GAAG,gBAAgB,CAAC,OAAO,GAAG,UAAU,EAAE,CAAC;YAChD,OAAO;QACT,CAAC;QAED,gBAAgB,CAAC,OAAO,GAAG,GAAG,CAAC;QAC/B,YAAY,CAAC,KAAK,CAAC,CAAC;QACpB,aAAa,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC;QAClC,WAAW,CAAC,OAAO,EAAE,CAAC,KAAK,CAAC,CAAC;IAC/B,CAAC,EAAE,CAAC,UAAU,CAAC,CAAC,CAAC;IAEjB,oBAAoB;IACpB,MAAM,UAAU,GAAG,WAAW,CAAC,GAAG,EAAE;QAClC,aAAa,CAAC,CAAC,CAAC,CAAC;QACjB,YAAY,CAAC,IAAI,CAAC,CAAC;QACnB,gBAAgB,CAAC,OAAO,GAAG,CAAC,CAAC;IAC/B,CAAC,EAAE,EAAE,CAAC,CAAC;IAEP,mBAAmB;IACnB,SAAS,CAAC,GAAG,EAAE;QACb,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,UAAU,EAAE,CAAC;QACf,CAAC;IACH,CAAC,EAAE,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC,CAAC;IAE1B,OAAO;QACL,SAAS;QACT,UAAU;QACV,UAAU;KACX,CAAC;AACJ,CAAC","sourcesContent":["import { useState, useCallback, useRef, useEffect } from 'react';\nimport type { BlinkEvent, UseBlinkDetectionResult } from '../types';\n\n/**\n * Options for useBlinkDetection hook\n */\nexport interface UseBlinkDetectionOptions {\n  /** Whether blink detection is enabled. Default: true */\n  enabled?: boolean;\n  \n  /** Minimum time between blinks in milliseconds. Default: 300 */\n  debounceMs?: number;\n  \n  /** Callback when a blink is detected */\n  onBlink?: (event: BlinkEvent) => void;\n}\n\n/**\n * Hook for managing blink detection state\n * \n * @param options - Blink detection options\n * @returns Blink detection state and controls\n * \n * @example\n * ```tsx\n * function BlinkCounter() {\n *   const { lastBlink, blinkCount, resetCount } = useBlinkDetection({\n *     debounceMs: 300,\n *     onBlink: (event) => {\n *       console.log('Blink detected at', event.timestamp);\n *     },\n *   });\n *   \n *   return (\n *     <View>\n *       <Text>Blinks: {blinkCount}</Text>\n *       <Button onPress={resetCount} title=\"Reset\" />\n *     </View>\n *   );\n * }\n * ```\n */\nexport function useBlinkDetection(\n  options: UseBlinkDetectionOptions = {}\n): UseBlinkDetectionResult {\n  const { enabled = true, debounceMs = 300, onBlink } = options;\n  \n  const [lastBlink, setLastBlink] = useState<BlinkEvent | null>(null);\n  const [blinkCount, setBlinkCount] = useState(0);\n  const callbackRef = useRef(onBlink);\n  const lastBlinkTimeRef = useRef(0);\n\n  // Keep callback ref updated\n  useEffect(() => {\n    callbackRef.current = onBlink;\n  }, [onBlink]);\n\n  // Handle blink event (called from frame processor)\n  const handleBlink = useCallback((event: BlinkEvent) => {\n    const now = Date.now();\n    \n    // Apply debounce\n    if (now - lastBlinkTimeRef.current < debounceMs) {\n      return;\n    }\n    \n    lastBlinkTimeRef.current = now;\n    setLastBlink(event);\n    setBlinkCount((prev) => prev + 1);\n    callbackRef.current?.(event);\n  }, [debounceMs]);\n\n  // Reset blink count\n  const resetCount = useCallback(() => {\n    setBlinkCount(0);\n    setLastBlink(null);\n    lastBlinkTimeRef.current = 0;\n  }, []);\n\n  // Reset on disable\n  useEffect(() => {\n    if (!enabled) {\n      resetCount();\n    }\n  }, [enabled, resetCount]);\n\n  return {\n    lastBlink,\n    blinkCount,\n    resetCount,\n  };\n}\n\n"]}
+{"version":3,"file":"useBlinkDetection.js","sourceRoot":"","sources":["../../src/hooks/useBlinkDetection.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAiBjE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,MAAM,UAAU,iBAAiB,CAC/B,UAAoC,EAAE;IAEtC,MAAM,EACJ,OAAO,GAAG,IAAI,EACd,kBAAkB,GAAG,GAAG,EACxB,iBAAiB,EAClB,GAAG,OAAO,CAAC;IAEZ,MAAM,CAAC,SAAS,EAAE,YAAY,CAAC,GAAG,QAAQ,CAAyB,IAAI,CAAC,CAAC;IACzE,MAAM,WAAW,GAAG,MAAM,CAAC,iBAAiB,CAAC,CAAC;IAE9C,4BAA4B;IAC5B,SAAS,CAAC,GAAG,EAAE;QACb,WAAW,CAAC,OAAO,GAAG,iBAAiB,CAAC;IAC1C,CAAC,EAAE,CAAC,iBAAiB,CAAC,CAAC,CAAC;IAExB,iFAAiF;IACjF,MAAM,gBAAgB,GAAG,WAAW,CAAC,CAAC,KAAa,EAAE,EAAE;;QACrD,IAAI,CAAC,OAAO,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACnC,OAAO;QACT,CAAC;QAED,sCAAsC;QACtC,MAAM,IAAI,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;QAEtB,yCAAyC;QACzC,IACE,IAAI,CAAC,sBAAsB,KAAK,SAAS;YACzC,IAAI,CAAC,uBAAuB,KAAK,SAAS,EAC1C,CAAC;YACD,OAAO;QACT,CAAC;QAED,MAAM,mBAAmB,GAAG,IAAI,CAAC,sBAAsB,CAAC;QACxD,MAAM,oBAAoB,GAAG,IAAI,CAAC,uBAAuB,CAAC;QAC1D,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QAEvB,MAAM,MAAM,GAAoB;YAC9B,OAAO,EAAE;gBACP,eAAe,EAAE,mBAAmB;gBACpC,QAAQ,EAAE,mBAAmB,GAAG,kBAAkB;aACnD;YACD,QAAQ,EAAE;gBACR,eAAe,EAAE,oBAAoB;gBACrC,QAAQ,EAAE,oBAAoB,GAAG,kBAAkB;aACpD;YACD,MAAM,EAAE,IAAI,CAAC,UAAU;YACvB,SAAS,EAAE,GAAG;SACf,CAAC;QAEF,YAAY,CAAC,MAAM,CAAC,CAAC;QACrB,MAAA,WAAW,CAAC,OAAO,4DAAG,MAAM,CAAC,CAAC;IAChC,CAAC,EAAE,CAAC,OAAO,EAAE,kBAAkB,CAAC,CAAC,CAAC;IAElC,mBAAmB;IACnB,MAAM,KAAK,GAAG,WAAW,CAAC,GAAG,EAAE;QAC7B,YAAY,CAAC,IAAI,CAAC,CAAC;IACrB,CAAC,EAAE,EAAE,CAAC,CAAC;IAEP,mBAAmB;IACnB,SAAS,CAAC,GAAG,EAAE;QACb,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,KAAK,EAAE,CAAC;QACV,CAAC;IACH,CAAC,EAAE,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC,CAAC;IAErB,OAAO;QACL,SAAS;QACT,gBAAgB;QAChB,KAAK;KACN,CAAC;AACJ,CAAC"}

package/build/hooks/useFaceDetection.js

@@ -43,15 +43,16 @@ export function useFaceDetection(options = {}) {
     }, [onFacesChanged]);
     // Update faces (called from frame processor via native bridge)
     const updateFaces = useCallback((newFaces) => {
+        var _a;
         // Limit number of faces
         const limitedFaces = newFaces.slice(0, maxFaces);
         // Only update if faces changed
         const facesChanged = limitedFaces.length !== facesRef.current.length ||
-            limitedFaces.some((face, i) => face.trackingId !== facesRef.current[i]?.trackingId);
+            limitedFaces.some((face, i) => { var _a; return face.trackingId !== ((_a = facesRef.current[i]) === null || _a === void 0 ? void 0 : _a.trackingId); });
         if (facesChanged) {
             facesRef.current = limitedFaces;
             setFaces(limitedFaces);
-            callbackRef.current?.(limitedFaces);
+            (_a = callbackRef.current) === null || _a === void 0 ? void 0 : _a.call(callbackRef, limitedFaces);
         }
     }, [maxFaces]);
     // Detection state management

package/build/hooks/useFaceDetection.js.map

@@ -1 +1 @@
-{"version":3,"file":"useFaceDetection.js","sourceRoot":"","sources":["../../src/hooks/useFaceDetection.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAiBjE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,MAAM,UAAU,gBAAgB,CAAC,UAAmC,EAAE;IACpE,MAAM,EAAE,OAAO,GAAG,IAAI,EAAE,QAAQ,GAAG,CAAC,EAAE,cAAc,EAAE,GAAG,OAAO,CAAC;IAEjE,MAAM,CAAC,KAAK,EAAE,QAAQ,CAAC,GAAG,QAAQ,CAAS,EAAE,CAAC,CAAC;IAC/C,MAAM,CAAC,WAAW,EAAE,cAAc,CAAC,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC;IACtD,MAAM,QAAQ,GAAG,MAAM,CAAS,EAAE,CAAC,CAAC;IACpC,MAAM,WAAW,GAAG,MAAM,CAAC,cAAc,CAAC,CAAC;IAE3C,4BAA4B;IAC5B,SAAS,CAAC,GAAG,EAAE;QACb,WAAW,CAAC,OAAO,GAAG,cAAc,CAAC;IACvC,CAAC,EAAE,CAAC,cAAc,CAAC,CAAC,CAAC;IAErB,+DAA+D;IAC/D,MAAM,WAAW,GAAG,WAAW,CAAC,CAAC,QAAgB,EAAE,EAAE;QACnD,wBAAwB;QACxB,MAAM,YAAY,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC;QAEjD,+BAA+B;QAC/B,MAAM,YAAY,GAChB,YAAY,CAAC,MAAM,KAAK,QAAQ,CAAC,OAAO,CAAC,MAAM;YAC/C,YAAY,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,UAAU,KAAK,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC;QAEtF,IAAI,YAAY,EAAE,CAAC;YACjB,QAAQ,CAAC,OAAO,GAAG,YAAY,CAAC;YAChC,QAAQ,CAAC,YAAY,CAAC,CAAC;YACvB,WAAW,CAAC,OAAO,EAAE,CAAC,YAAY,CAAC,CAAC;QACtC,CAAC;IACH,CAAC,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAC;IAEf,6BAA6B;IAC7B,MAAM,cAAc,GAAG,WAAW,CAAC,GAAG,EAAE;QACtC,cAAc,CAAC,IAAI,CAAC,CAAC;IACvB,CAAC,EAAE,EAAE,CAAC,CAAC;IAEP,MAAM,aAAa,GAAG,WAAW,CAAC,GAAG,EAAE;QACrC,cAAc,CAAC,KAAK,CAAC,CAAC;QACtB,QAAQ,CAAC,EAAE,CAAC,CAAC;QACb,QAAQ,CAAC,OAAO,GAAG,EAAE,CAAC;IACxB,CAAC,EAAE,EAAE,CAAC,CAAC;IAEP,yDAAyD;IACzD,SAAS,CAAC,GAAG,EAAE;QACb,IAAI,OAAO,EAAE,CAAC;YACZ,cAAc,EAAE,CAAC;QACnB,CAAC;aAAM,CAAC;YACN,aAAa,EAAE,CAAC;QAClB,CAAC;IACH,CAAC,EAAE,CAAC,OAAO,EAAE,cAAc,EAAE,aAAa,CAAC,CAAC,CAAC;IAE7C,OAAO;QACL,KAAK;QACL,WAAW;KACZ,CAAC;AACJ,CAAC","sourcesContent":["import { useState, useCallback, useRef, useEffect } from 'react';\nimport type { Face, FaceDetectionOptions, UseFaceDetectionResult } from '../types';\n\n/**\n * Options for useFaceDetection hook\n */\nexport interface UseFaceDetectionOptions extends FaceDetectionOptions {\n  /** Whether detection is enabled. Default: true */\n  enabled?: boolean;\n  \n  /** Maximum number of faces to track. Default: 5 */\n  maxFaces?: number;\n  \n  /** Callback when faces change */\n  onFacesChanged?: (faces: Face[]) => void;\n}\n\n/**\n * Hook for managing face detection state\n * \n * Use this hook to get face detection results outside of the SmartCamera component.\n * \n * @param options - Face detection options\n * @returns Face detection state\n * \n * @example\n * ```tsx\n * function FaceTracker() {\n *   const { faces, isDetecting } = useFaceDetection({\n *     performanceMode: 'fast',\n *     classificationMode: 'all',\n *     onFacesChanged: (faces) => {\n *       console.log('Detected faces:', faces.length);\n *     },\n *   });\n *   \n *   return (\n *     <View>\n *       <Text>Faces detected: {faces.length}</Text>\n *       {faces.map((face, i) => (\n *         <Text key={i}>\n *           Smiling: {(face.smilingProbability ?? 0) * 100}%\n *         </Text>\n *       ))}\n *     </View>\n *   );\n * }\n * ```\n */\nexport function useFaceDetection(options: UseFaceDetectionOptions = {}): UseFaceDetectionResult {\n  const { enabled = true, maxFaces = 5, onFacesChanged } = options;\n  \n  const [faces, setFaces] = useState<Face[]>([]);\n  const [isDetecting, setIsDetecting] = useState(false);\n  const facesRef = useRef<Face[]>([]);\n  const callbackRef = useRef(onFacesChanged);\n\n  // Keep callback ref updated\n  useEffect(() => {\n    callbackRef.current = onFacesChanged;\n  }, [onFacesChanged]);\n\n  // Update faces (called from frame processor via native bridge)\n  const updateFaces = useCallback((newFaces: Face[]) => {\n    // Limit number of faces\n    const limitedFaces = newFaces.slice(0, maxFaces);\n    \n    // Only update if faces changed\n    const facesChanged = \n      limitedFaces.length !== facesRef.current.length ||\n      limitedFaces.some((face, i) => face.trackingId !== facesRef.current[i]?.trackingId);\n    \n    if (facesChanged) {\n      facesRef.current = limitedFaces;\n      setFaces(limitedFaces);\n      callbackRef.current?.(limitedFaces);\n    }\n  }, [maxFaces]);\n\n  // Detection state management\n  const startDetecting = useCallback(() => {\n    setIsDetecting(true);\n  }, []);\n\n  const stopDetecting = useCallback(() => {\n    setIsDetecting(false);\n    setFaces([]);\n    facesRef.current = [];\n  }, []);\n\n  // Effect to manage detection state based on enabled prop\n  useEffect(() => {\n    if (enabled) {\n      startDetecting();\n    } else {\n      stopDetecting();\n    }\n  }, [enabled, startDetecting, stopDetecting]);\n\n  return {\n    faces,\n    isDetecting,\n  };\n}\n\n"]}
+{"version":3,"file":"useFaceDetection.js","sourceRoot":"","sources":["../../src/hooks/useFaceDetection.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAiBjE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,MAAM,UAAU,gBAAgB,CAAC,UAAmC,EAAE;IACpE,MAAM,EAAE,OAAO,GAAG,IAAI,EAAE,QAAQ,GAAG,CAAC,EAAE,cAAc,EAAE,GAAG,OAAO,CAAC;IAEjE,MAAM,CAAC,KAAK,EAAE,QAAQ,CAAC,GAAG,QAAQ,CAAS,EAAE,CAAC,CAAC;IAC/C,MAAM,CAAC,WAAW,EAAE,cAAc,CAAC,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC;IACtD,MAAM,QAAQ,GAAG,MAAM,CAAS,EAAE,CAAC,CAAC;IACpC,MAAM,WAAW,GAAG,MAAM,CAAC,cAAc,CAAC,CAAC;IAE3C,4BAA4B;IAC5B,SAAS,CAAC,GAAG,EAAE;QACb,WAAW,CAAC,OAAO,GAAG,cAAc,CAAC;IACvC,CAAC,EAAE,CAAC,cAAc,CAAC,CAAC,CAAC;IAErB,+DAA+D;IAC/D,MAAM,WAAW,GAAG,WAAW,CAAC,CAAC,QAAgB,EAAE,EAAE;;QACnD,wBAAwB;QACxB,MAAM,YAAY,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC;QAEjD,+BAA+B;QAC/B,MAAM,YAAY,GAChB,YAAY,CAAC,MAAM,KAAK,QAAQ,CAAC,OAAO,CAAC,MAAM;YAC/C,YAAY,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,CAAC,EAAE,EAAE,WAAC,OAAA,IAAI,CAAC,UAAU,MAAK,MAAA,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,0CAAE,UAAU,CAAA,CAAA,EAAA,CAAC,CAAC;QAEtF,IAAI,YAAY,EAAE,CAAC;YACjB,QAAQ,CAAC,OAAO,GAAG,YAAY,CAAC;YAChC,QAAQ,CAAC,YAAY,CAAC,CAAC;YACvB,MAAA,WAAW,CAAC,OAAO,4DAAG,YAAY,CAAC,CAAC;QACtC,CAAC;IACH,CAAC,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAC;IAEf,6BAA6B;IAC7B,MAAM,cAAc,GAAG,WAAW,CAAC,GAAG,EAAE;QACtC,cAAc,CAAC,IAAI,CAAC,CAAC;IACvB,CAAC,EAAE,EAAE,CAAC,CAAC;IAEP,MAAM,aAAa,GAAG,WAAW,CAAC,GAAG,EAAE;QACrC,cAAc,CAAC,KAAK,CAAC,CAAC;QACtB,QAAQ,CAAC,EAAE,CAAC,CAAC;QACb,QAAQ,CAAC,OAAO,GAAG,EAAE,CAAC;IACxB,CAAC,EAAE,EAAE,CAAC,CAAC;IAEP,yDAAyD;IACzD,SAAS,CAAC,GAAG,EAAE;QACb,IAAI,OAAO,EAAE,CAAC;YACZ,cAAc,EAAE,CAAC;QACnB,CAAC;aAAM,CAAC;YACN,aAAa,EAAE,CAAC;QAClB,CAAC;IACH,CAAC,EAAE,CAAC,OAAO,EAAE,cAAc,EAAE,aAAa,CAAC,CAAC,CAAC;IAE7C,OAAO;QACL,KAAK;QACL,WAAW;KACZ,CAAC;AACJ,CAAC"}

package/build/hooks/useFaceDetector.d.ts

@@ -0,0 +1,123 @@
+import type { Frame } from 'react-native-vision-camera';
+import type { Face, FaceDetectionOptions, CameraFacing } from '../types';
+/**
+ * Face detection options for useFaceDetector hook
+ * Matches the API of react-native-vision-camera-face-detector
+ */
+export interface UseFaceDetectorOptions extends FaceDetectionOptions {
+    /**
+     * Current active camera
+     * @default 'front'
+     */
+    cameraFacing?: CameraFacing;
+    /**
+     * Should handle auto scale on native side?
+     * If disabled, results are relative to frame coordinates, not screen/preview.
+     * Don't use this if you want to draw with Skia Frame Processor.
+     * @default false
+     */
+    autoMode?: boolean;
+    /**
+     * Screen width for coordinate scaling (required when autoMode is true)
+     * @default 1.0
+     */
+    windowWidth?: number;
+    /**
+     * Screen height for coordinate scaling (required when autoMode is true)
+     * @default 1.0
+     */
+    windowHeight?: number;
+}
+/**
+ * Return type for useFaceDetector hook
+ */
+export interface UseFaceDetectorResult {
+    /**
+     * Detect faces in a frame (for use in frame processor)
+     */
+    detectFaces: (frame: Frame) => Face[];
+}
+/**
+ * Hook for face detection in VisionCamera frame processors.
+ *
+ * This hook provides a `detectFaces` function that can be used directly
+ * in a frame processor to detect faces in each frame.
+ *
+ * @param options - Face detection options
+ * @returns Object with detectFaces function
+ *
+ * @example
+ * ```tsx
+ * import { useFaceDetector } from '@arfuhad/react-native-smart-camera';
+ * import { useFrameProcessor } from 'react-native-vision-camera';
+ * import Worklets from 'react-native-worklets-core';
+ *
+ * function FaceDetectionCamera() {
+ *   const { detectFaces } = useFaceDetector({
+ *     performanceMode: 'fast',
+ *     classificationMode: 'all', // Required for blink detection
+ *   });
+ *
+ *   const handleFaces = Worklets.createRunOnJS((faces: Face[]) => {
+ *     console.log('Detected faces:', faces.length);
+ *     // Check for blinks using leftEyeOpenProbability / rightEyeOpenProbability
+ *   });
+ *
+ *   const frameProcessor = useFrameProcessor((frame) => {
+ *     'worklet';
+ *     const faces = detectFaces(frame);
+ *     handleFaces(faces);
+ *   }, [detectFaces, handleFaces]);
+ *
+ *   return <Camera frameProcessor={frameProcessor} />;
+ * }
+ * ```
+ */
+export declare function useFaceDetector(options?: UseFaceDetectorOptions): UseFaceDetectorResult;
+/**
+ * Callback type for face detection
+ */
+export type FaceDetectionCallback = (faces: Face[]) => void;
+/**
+ * Options for useFaceDetectorWithCallback hook
+ */
+export interface UseFaceDetectorWithCallbackOptions extends UseFaceDetectorOptions {
+    /**
+     * Callback when faces are detected
+     */
+    onFacesDetected?: FaceDetectionCallback;
+}
+/**
+ * Hook for face detection with automatic callback handling
+ *
+ * This is a convenience hook that wraps useFaceDetector and automatically
+ * calls your callback function when faces are detected.
+ *
+ * @param options - Face detection options with callback
+ * @returns Object with detectFaces function for use in frame processor
+ *
+ * @example
+ * ```tsx
+ * import { useFaceDetectorWithCallback } from '@arfuhad/react-native-smart-camera';
+ *
+ * function FaceDetectionCamera() {
+ *   const [faces, setFaces] = useState<Face[]>([]);
+ *
+ *   const { detectFaces } = useFaceDetectorWithCallback({
+ *     classificationMode: 'all',
+ *     onFacesDetected: (detectedFaces) => {
+ *       setFaces(detectedFaces);
+ *     },
+ *   });
+ *
+ *   const frameProcessor = useFrameProcessor((frame) => {
+ *     'worklet';
+ *     detectFaces(frame); // Automatically calls onFacesDetected
+ *   }, [detectFaces]);
+ *
+ *   return <Camera frameProcessor={frameProcessor} />;
+ * }
+ * ```
+ */
+export declare function useFaceDetectorWithCallback(options?: UseFaceDetectorWithCallbackOptions): UseFaceDetectorResult;
+//# sourceMappingURL=useFaceDetector.d.ts.map

package/build/hooks/useFaceDetector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFaceDetector.d.ts","sourceRoot":"","sources":["../../src/hooks/useFaceDetector.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,4BAA4B,CAAC;AAExD,OAAO,KAAK,EAAE,IAAI,EAAE,oBAAoB,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAEzE;;;GAGG;AACH,MAAM,WAAW,sBAAuB,SAAQ,oBAAoB;IAClE;;;OAGG;IACH,YAAY,CAAC,EAAE,YAAY,CAAC;IAE5B;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IAEnB;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC;;OAEG;IACH,WAAW,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,EAAE,CAAC;CACvC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAgB,eAAe,CAAC,OAAO,GAAE,sBAA2B,GAAG,qBAAqB,CA4B3F;AAED;;GAEG;AACH,MAAM,MAAM,qBAAqB,GAAG,CAAC,KAAK,EAAE,IAAI,EAAE,KAAK,IAAI,CAAC;AAE5D;;GAEG;AACH,MAAM,WAAW,kCAAmC,SAAQ,sBAAsB;IAChF;;OAEG;IACH,eAAe,CAAC,EAAE,qBAAqB,CAAC;CACzC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,2BAA2B,CACzC,OAAO,GAAE,kCAAuC,GAC/C,qBAAqB,CA0BvB"}

package/build/hooks/useFaceDetector.js

@@ -0,0 +1,133 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { useCallback, useRef, useEffect } from 'react';
+import { useRunOnJS } from 'react-native-worklets-core';
+import { detectFaces } from '../detection/faceDetector';
+/**
+ * Hook for face detection in VisionCamera frame processors.
+ *
+ * This hook provides a `detectFaces` function that can be used directly
+ * in a frame processor to detect faces in each frame.
+ *
+ * @param options - Face detection options
+ * @returns Object with detectFaces function
+ *
+ * @example
+ * ```tsx
+ * import { useFaceDetector } from '@arfuhad/react-native-smart-camera';
+ * import { useFrameProcessor } from 'react-native-vision-camera';
+ * import Worklets from 'react-native-worklets-core';
+ *
+ * function FaceDetectionCamera() {
+ *   const { detectFaces } = useFaceDetector({
+ *     performanceMode: 'fast',
+ *     classificationMode: 'all', // Required for blink detection
+ *   });
+ *
+ *   const handleFaces = Worklets.createRunOnJS((faces: Face[]) => {
+ *     console.log('Detected faces:', faces.length);
+ *     // Check for blinks using leftEyeOpenProbability / rightEyeOpenProbability
+ *   });
+ *
+ *   const frameProcessor = useFrameProcessor((frame) => {
+ *     'worklet';
+ *     const faces = detectFaces(frame);
+ *     handleFaces(faces);
+ *   }, [detectFaces, handleFaces]);
+ *
+ *   return <Camera frameProcessor={frameProcessor} />;
+ * }
+ * ```
+ */
+export function useFaceDetector(options = {}) {
+    const optionsRef = useRef(options);
+    // Keep options ref updated
+    useEffect(() => {
+        optionsRef.current = options;
+    }, [options]);
+    // Create detect function that uses current options
+    const detect = useCallback((frame) => {
+        'worklet';
+        return detectFaces(frame, {
+            performanceMode: optionsRef.current.performanceMode,
+            landmarkMode: optionsRef.current.landmarkMode,
+            contourMode: optionsRef.current.contourMode,
+            classificationMode: optionsRef.current.classificationMode,
+            minFaceSize: optionsRef.current.minFaceSize,
+            trackingEnabled: optionsRef.current.trackingEnabled,
+            cameraFacing: optionsRef.current.cameraFacing,
+            autoMode: optionsRef.current.autoMode,
+            windowWidth: optionsRef.current.windowWidth,
+            windowHeight: optionsRef.current.windowHeight,
+        });
+    }, []);
+    return {
+        detectFaces: detect,
+    };
+}
+/**
+ * Hook for face detection with automatic callback handling
+ *
+ * This is a convenience hook that wraps useFaceDetector and automatically
+ * calls your callback function when faces are detected.
+ *
+ * @param options - Face detection options with callback
+ * @returns Object with detectFaces function for use in frame processor
+ *
+ * @example
+ * ```tsx
+ * import { useFaceDetectorWithCallback } from '@arfuhad/react-native-smart-camera';
+ *
+ * function FaceDetectionCamera() {
+ *   const [faces, setFaces] = useState<Face[]>([]);
+ *
+ *   const { detectFaces } = useFaceDetectorWithCallback({
+ *     classificationMode: 'all',
+ *     onFacesDetected: (detectedFaces) => {
+ *       setFaces(detectedFaces);
+ *     },
+ *   });
+ *
+ *   const frameProcessor = useFrameProcessor((frame) => {
+ *     'worklet';
+ *     detectFaces(frame); // Automatically calls onFacesDetected
+ *   }, [detectFaces]);
+ *
+ *   return <Camera frameProcessor={frameProcessor} />;
+ * }
+ * ```
+ */
+export function useFaceDetectorWithCallback(options = {}) {
+    const { onFacesDetected } = options, detectorOptions = __rest(options, ["onFacesDetected"]);
+    const { detectFaces: baseDet } = useFaceDetector(detectorOptions);
+    const callbackRef = useRef(onFacesDetected);
+    useEffect(() => {
+        callbackRef.current = onFacesDetected;
+    }, [onFacesDetected]);
+    // Create runOnJS callback
+    const handleFacesDetected = useRunOnJS((faces) => {
+        var _a;
+        (_a = callbackRef.current) === null || _a === void 0 ? void 0 : _a.call(callbackRef, faces);
+    }, []);
+    const detectWithCallback = useCallback((frame) => {
+        'worklet';
+        const faces = baseDet(frame);
+        if (faces.length > 0 || callbackRef.current) {
+            handleFacesDetected(faces);
+        }
+        return faces;
+    }, [baseDet, handleFacesDetected]);
+    return {
+        detectFaces: detectWithCallback,
+    };
+}
+//# sourceMappingURL=useFaceDetector.js.map

package/build/hooks/useFaceDetector.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFaceDetector.js","sourceRoot":"","sources":["../../src/hooks/useFaceDetector.ts"],"names":[],"mappings":";;;;;;;;;;;AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,SAAS,EAAY,MAAM,OAAO,CAAC;AACjE,OAAO,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAExD,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AA6CxD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,MAAM,UAAU,eAAe,CAAC,UAAkC,EAAE;IAClE,MAAM,UAAU,GAAG,MAAM,CAAC,OAAO,CAAC,CAAC;IAEnC,2BAA2B;IAC3B,SAAS,CAAC,GAAG,EAAE;QACb,UAAU,CAAC,OAAO,GAAG,OAAO,CAAC;IAC/B,CAAC,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC;IAEd,mDAAmD;IACnD,MAAM,MAAM,GAAG,WAAW,CAAC,CAAC,KAAY,EAAU,EAAE;QAClD,SAAS,CAAC;QACV,OAAO,WAAW,CAAC,KAAK,EAAE;YACxB,eAAe,EAAE,UAAU,CAAC,OAAO,CAAC,eAAe;YACnD,YAAY,EAAE,UAAU,CAAC,OAAO,CAAC,YAAY;YAC7C,WAAW,EAAE,UAAU,CAAC,OAAO,CAAC,WAAW;YAC3C,kBAAkB,EAAE,UAAU,CAAC,OAAO,CAAC,kBAAkB;YACzD,WAAW,EAAE,UAAU,CAAC,OAAO,CAAC,WAAW;YAC3C,eAAe,EAAE,UAAU,CAAC,OAAO,CAAC,eAAe;YACnD,YAAY,EAAE,UAAU,CAAC,OAAO,CAAC,YAAY;YAC7C,QAAQ,EAAE,UAAU,CAAC,OAAO,CAAC,QAAQ;YACrC,WAAW,EAAE,UAAU,CAAC,OAAO,CAAC,WAAW;YAC3C,YAAY,EAAE,UAAU,CAAC,OAAO,CAAC,YAAY;SAC9C,CAAC,CAAC;IACL,CAAC,EAAE,EAAE,CAAC,CAAC;IAEP,OAAO;QACL,WAAW,EAAE,MAAM;KACpB,CAAC;AACJ,CAAC;AAiBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,MAAM,UAAU,2BAA2B,CACzC,UAA8C,EAAE;IAEhD,MAAM,EAAE,eAAe,KAAyB,OAAO,EAA3B,eAAe,UAAK,OAAO,EAAjD,mBAAuC,CAAU,CAAC;IACxD,MAAM,EAAE,WAAW,EAAE,OAAO,EAAE,GAAG,eAAe,CAAC,eAAe,CAAC,CAAC;IAClE,MAAM,WAAW,GAAG,MAAM,CAAC,eAAe,CAAC,CAAC;IAE5C,SAAS,CAAC,GAAG,EAAE;QACb,WAAW,CAAC,OAAO,GAAG,eAAe,CAAC;IACxC,CAAC,EAAE,CAAC,eAAe,CAAC,CAAC,CAAC;IAEtB,0BAA0B;IAC1B,MAAM,mBAAmB,GAAG,UAAU,CAAC,CAAC,KAAa,EAAE,EAAE;;QACvD,MAAA,WAAW,CAAC,OAAO,4DAAG,KAAK,CAAC,CAAC;IAC/B,CAAC,EAAE,EAAE,CAAC,CAAC;IAEP,MAAM,kBAAkB,GAAG,WAAW,CAAC,CAAC,KAAY,EAAU,EAAE;QAC9D,SAAS,CAAC;QACV,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;QAC7B,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,IAAI,WAAW,CAAC,OAAO,EAAE,CAAC;YAC5C,mBAAmB,CAAC,KAAK,CAAC,CAAC;QAC7B,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC,EAAE,CAAC,OAAO,EAAE,mBAAmB,CAAC,CAAC,CAAC;IAEnC,OAAO;QACL,WAAW,EAAE,kBAAkB;KAChC,CAAC;AACJ,CAAC"}