@souscheflabs/ml-vision 0.1.0

package/dist/hooks/useVideoScanner.js

@@ -0,0 +1,383 @@
+"use strict";
+/**
+ * useVideoScanner Hook
+ *
+ * React hook for real-time video scanning combining product detection,
+ * barcode scanning, and text recognition.
+ *
+ * @example
+ * ```typescript
+ * import { useVideoScanner } from '@souschef/ml-vision';
+ *
+ * function LiveScanner() {
+ *   const {
+ *     isScanning,
+ *     products,
+ *     barcodes,
+ *     startScanning,
+ *     stopScanning,
+ *     cameraRef,
+ *   } = useVideoScanner({
+ *     modes: ['products', 'barcodes'],
+ *     onDetected: (results) => console.log('Found:', results),
+ *   });
+ *
+ *   return (
+ *     <Camera ref={cameraRef} />
+ *   );
+ * }
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useVideoScanner = useVideoScanner;
+const react_1 = require("react");
+const MLVisionProvider_1 = require("../core/MLVisionProvider");
+const useProductDetector_1 = require("./useProductDetector");
+const useMultiBarcodeScanner_1 = require("./useMultiBarcodeScanner");
+const tfliteFrameProcessor_1 = require("../processors/tfliteFrameProcessor");
+const classLabelsCoco_1 = require("./classLabelsCoco");
+// ============================================================================
+// Constants
+// ============================================================================
+const DEFAULT_TARGET_FPS = 10;
+const DEFAULT_SMOOTHING_FRAMES = 3;
+const MS_PER_SECOND = 1000;
+// ============================================================================
+// Hook Implementation
+// ============================================================================
+/**
+ * Hook for real-time video scanning
+ */
+function useVideoScanner(options = {}) {
+    const { modes = ['products', 'barcodes'], targetFps = DEFAULT_TARGET_FPS, minProductConfidence = 0.5, productCategories, maxProducts = 10, maxBarcodes = 5, temporalSmoothing = true, smoothingFrames = DEFAULT_SMOOTHING_FRAMES, onDetected, onError, hapticFeedback = true, 
+    // TFLite options
+    tfliteModel, useOnDeviceFrameProcessor = !!tfliteModel, foodOnly = true, } = options;
+    // Context
+    const { isInitialized } = (0, MLVisionProvider_1.useMLVisionContext)();
+    // Child hooks
+    const productDetector = (0, useProductDetector_1.useProductDetector)({
+        model: 'fast',
+        minConfidence: minProductConfidence,
+        categories: productCategories,
+        maxDetections: maxProducts,
+        hapticFeedback: false, // We'll handle haptics at video level
+    });
+    const barcodeScanner = (0, useMultiBarcodeScanner_1.useMultiBarcodeScanner)({
+        maxBarcodes,
+        hapticFeedback: false,
+    });
+    // State
+    const [isScanning, setIsScanning] = (0, react_1.useState)(false);
+    const [products, setProducts] = (0, react_1.useState)([]);
+    const [barcodes, setBarcodes] = (0, react_1.useState)([]);
+    const [frameNumber, setFrameNumber] = (0, react_1.useState)(0);
+    const [fps, setFps] = (0, react_1.useState)(0);
+    const [error, setError] = (0, react_1.useState)(null);
+    const [inferenceTimeMs, _setInferenceTimeMs] = (0, react_1.useState)(0);
+    // ============================================================================
+    // TFLite Frame Processor (for real-time video detection)
+    // ============================================================================
+    /**
+     * Convert TFLite detection to ProductDetectionResult
+     */
+    const tfliteToProductResult = (0, react_1.useCallback)((detection) => {
+        return {
+            id: `tflite_${Date.now()}_${detection.classIndex}`,
+            type: 'product',
+            confidence: detection.confidence,
+            boundingBox: {
+                x: detection.x,
+                y: detection.y,
+                width: detection.width,
+                height: detection.height,
+            },
+            source: 'on_device',
+            processingTimeMs: 0,
+            timestamp: Date.now(),
+            data: {
+                category: 'produce', // Map to closest ProductCategory
+                classLabel: detection.label,
+                classIndex: detection.classIndex,
+                name: detection.label.charAt(0).toUpperCase() + detection.label.slice(1),
+            },
+        };
+    }, []);
+    /**
+     * Handle TFLite detections
+     */
+    const handleTFLiteDetections = (0, react_1.useCallback)((detections) => {
+        const productResults = detections.map(tfliteToProductResult);
+        setProducts(productResults);
+        setFrameNumber((prev) => prev + 1);
+        // Callback
+        if (productResults.length > 0 && onDetected) {
+            onDetected({
+                products: productResults,
+                barcodes,
+                timestamp: Date.now(),
+                frameNumber,
+            });
+        }
+    }, [tfliteToProductResult, barcodes, frameNumber, onDetected]);
+    // TFLite frame processor hook
+    const tfliteFrameProcessor = (0, tfliteFrameProcessor_1.useTFLiteFrameProcessor)({
+        model: useOnDeviceFrameProcessor ? tfliteModel ?? null : null,
+        numClasses: 80, // COCO
+        confThreshold: minProductConfidence,
+        classLabels: [...classLabelsCoco_1.COCO_CLASSES], // Convert readonly to mutable array
+        foodOnly,
+        onDetections: handleTFLiteDetections,
+    });
+    // Refs
+    const cameraRef = (0, react_1.useRef)(null);
+    const lastFrameTimeRef = (0, react_1.useRef)(0);
+    const frameCountRef = (0, react_1.useRef)(0);
+    const fpsStartTimeRef = (0, react_1.useRef)(Date.now());
+    const productHistoryRef = (0, react_1.useRef)([]);
+    const mountedRef = (0, react_1.useRef)(true);
+    // Computed readiness
+    const isReady = (0, react_1.useMemo)(() => {
+        // For products: either TFLite frame processor is ready, or productDetector is loaded
+        const productReady = !modes.includes('products') ||
+            (useOnDeviceFrameProcessor ? tfliteFrameProcessor.isReady : productDetector.isModelLoaded);
+        const barcodeReady = !modes.includes('barcodes') || barcodeScanner.isReady;
+        return isInitialized && productReady && barcodeReady;
+    }, [
+        isInitialized,
+        modes,
+        useOnDeviceFrameProcessor,
+        tfliteFrameProcessor.isReady,
+        productDetector.isModelLoaded,
+        barcodeScanner.isReady,
+    ]);
+    // ============================================================================
+    // FPS Calculation
+    // ============================================================================
+    (0, react_1.useEffect)(() => {
+        if (!isScanning)
+            return;
+        const interval = setInterval(() => {
+            const now = Date.now();
+            const elapsed = (now - fpsStartTimeRef.current) / MS_PER_SECOND;
+            if (elapsed > 0) {
+                setFps(Math.round(frameCountRef.current / elapsed));
+            }
+            frameCountRef.current = 0;
+            fpsStartTimeRef.current = now;
+        }, MS_PER_SECOND);
+        return () => clearInterval(interval);
+    }, [isScanning]);
+    // ============================================================================
+    // Temporal Smoothing
+    // ============================================================================
+    /**
+     * Apply temporal smoothing to product detections
+     */
+    const smoothProducts = (0, react_1.useCallback)((newProducts) => {
+        if (!temporalSmoothing)
+            return newProducts;
+        // Add to history
+        productHistoryRef.current.push(newProducts);
+        if (productHistoryRef.current.length > smoothingFrames) {
+            productHistoryRef.current.shift();
+        }
+        // Count occurrences of each class
+        const classCounts = new Map();
+        const bestDetections = new Map();
+        for (const frameProducts of productHistoryRef.current) {
+            for (const product of frameProducts) {
+                const key = product.data.classLabel;
+                const count = (classCounts.get(key) || 0) + 1;
+                classCounts.set(key, count);
+                // Keep best confidence detection
+                const existing = bestDetections.get(key);
+                if (!existing || product.confidence > existing.confidence) {
+                    bestDetections.set(key, product);
+                }
+            }
+        }
+        // Keep products that appear in at least half the frames
+        const threshold = Math.ceil(smoothingFrames / 2);
+        return Array.from(bestDetections.entries())
+            .filter(([key]) => (classCounts.get(key) || 0) >= threshold)
+            .map(([, product]) => product);
+    }, [temporalSmoothing, smoothingFrames]);
+    // ============================================================================
+    // Frame Processing
+    // ============================================================================
+    /**
+     * Process a frame (called from frame processor)
+     * @deprecated Use TFLite frame processor instead
+     */
+    const _processFrame = (0, react_1.useCallback)(async (frameUri) => {
+        const now = Date.now();
+        const minInterval = MS_PER_SECOND / targetFps;
+        // Throttle based on target FPS
+        if (now - lastFrameTimeRef.current < minInterval) {
+            return;
+        }
+        lastFrameTimeRef.current = now;
+        frameCountRef.current++;
+        try {
+            const results = {
+                products: [],
+                barcodes: [],
+                timestamp: now,
+                frameNumber: frameNumber,
+            };
+            // Product detection
+            if (modes.includes('products') && productDetector.isModelLoaded) {
+                const detected = await productDetector.detectProducts(frameUri);
+                results.products = smoothProducts(detected);
+            }
+            // Barcode detection is handled by VisionCamera's code scanner
+            // Results come through barcodeScanner.results
+            // Update state
+            if (mountedRef.current) {
+                setFrameNumber((prev) => prev + 1);
+                if (results.products.length > 0) {
+                    setProducts(results.products);
+                }
+                // Combine with barcode results
+                results.barcodes = barcodeScanner.results;
+                // Callback
+                if (results.products.length > 0 || results.barcodes.length > 0) {
+                    onDetected?.(results);
+                    // Haptic feedback
+                    if (hapticFeedback) {
+                        // Trigger haptic
+                    }
+                }
+            }
+        }
+        catch (err) {
+            const frameError = err instanceof Error ? err : new Error('Frame processing failed');
+            console.error('[useVideoScanner] Frame error:', frameError);
+            setError(frameError);
+            onError?.(frameError);
+        }
+    }, [
+        targetFps,
+        frameNumber,
+        modes,
+        productDetector,
+        barcodeScanner.results,
+        smoothProducts,
+        onDetected,
+        onError,
+        hapticFeedback,
+    ]);
+    // ============================================================================
+    // Actions
+    // ============================================================================
+    /**
+     * Start video scanning
+     */
+    const startScanning = (0, react_1.useCallback)(() => {
+        if (!isReady) {
+            console.warn('[useVideoScanner] Not ready to scan');
+            return;
+        }
+        setIsScanning(true);
+        setError(null);
+        frameCountRef.current = 0;
+        fpsStartTimeRef.current = Date.now();
+        productHistoryRef.current = [];
+        // Start barcode scanner if enabled
+        if (modes.includes('barcodes')) {
+            barcodeScanner.startScanning();
+        }
+    }, [isReady, modes, barcodeScanner]);
+    /**
+     * Stop video scanning
+     */
+    const stopScanning = (0, react_1.useCallback)(() => {
+        setIsScanning(false);
+        barcodeScanner.stopScanning();
+    }, [barcodeScanner]);
+    /**
+     * Toggle scanning
+     */
+    const toggleScanning = (0, react_1.useCallback)(() => {
+        if (isScanning) {
+            stopScanning();
+        }
+        else {
+            startScanning();
+        }
+    }, [isScanning, startScanning, stopScanning]);
+    /**
+     * Clear all detections
+     */
+    const clearDetections = (0, react_1.useCallback)(() => {
+        setProducts([]);
+        setBarcodes([]);
+        barcodeScanner.clearResults();
+        productDetector.clearDetections();
+        productHistoryRef.current = [];
+    }, [barcodeScanner, productDetector]);
+    /**
+     * Capture current frame as photo
+     */
+    const captureFrame = (0, react_1.useCallback)(async () => {
+        // This would use VisionCamera's takePhoto method
+        // Requires ref to be properly typed and connected
+        console.log('[useVideoScanner] Frame capture requires VisionCamera ref');
+        return null;
+    }, []);
+    // ============================================================================
+    // Frame Processor Configuration
+    // ============================================================================
+    const frameProcessorConfig = (0, react_1.useMemo)(() => {
+        if (!isScanning)
+            return null;
+        return {
+            // For VisionCamera frame processor
+            // This would be used with useFrameProcessor
+            codeScanner: modes.includes('barcodes') ? barcodeScanner.frameProcessor : undefined,
+            // Product detection happens through processFrame
+        };
+    }, [isScanning, modes, barcodeScanner.frameProcessor]);
+    // ============================================================================
+    // Cleanup
+    // ============================================================================
+    (0, react_1.useEffect)(() => {
+        mountedRef.current = true;
+        return () => {
+            mountedRef.current = false;
+        };
+    }, []);
+    // Sync barcode results
+    (0, react_1.useEffect)(() => {
+        if (barcodeScanner.results.length > 0) {
+            setBarcodes(barcodeScanner.results);
+        }
+    }, [barcodeScanner.results]);
+    // ============================================================================
+    // Return
+    // ============================================================================
+    return {
+        // State
+        isScanning,
+        isReady,
+        products,
+        barcodes,
+        frameNumber,
+        fps,
+        error,
+        inferenceTimeMs,
+        // Actions
+        startScanning,
+        stopScanning,
+        toggleScanning,
+        clearDetections,
+        captureFrame,
+        // Camera ref
+        cameraRef,
+        // Frame processor config
+        frameProcessorConfig,
+        // TFLite frame processor (use this with VisionCamera)
+        frameProcessor: useOnDeviceFrameProcessor ? tfliteFrameProcessor.frameProcessor : undefined,
+    };
+}
+exports.default = useVideoScanner;

package/dist/index.d.ts

@@ -0,0 +1,58 @@
+/**
+ * @souschef/ml-vision
+ *
+ * ML-powered product detection for React Native
+ *
+ * Features:
+ * - Multi-barcode scanning (scan multiple barcodes at once)
+ * - Receipt OCR (photograph receipts to extract items)
+ * - Visual product recognition (recognize fridge/pantry contents)
+ * - Video scanning (real-time product detection)
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   MLVisionProvider,
+ *   useMultiBarcodeScanner,
+ *   useProductDetector,
+ *   useReceiptScanner,
+ * } from '@souschef/ml-vision';
+ *
+ * // Wrap your app with the provider
+ * function App() {
+ *   return (
+ *     <MLVisionProvider
+ *       config={{ serverUrl: 'http://192.168.1.100:8000' }}
+ *       storage={mmkvInstance}
+ *     >
+ *       <YourApp />
+ *     </MLVisionProvider>
+ *   );
+ * }
+ *
+ * // Use hooks in your components
+ * function ScannerScreen() {
+ *   const { scanPhoto, results } = useMultiBarcodeScanner();
+ *   const { detectProducts, detections } = useProductDetector();
+ *
+ *   // ...
+ * }
+ * ```
+ *
+ * @packageDocumentation
+ */
+export type { MLVisionConfig, BoundingBox, BaseDetectionResult, ModelInfo, ModelDownloadProgress, CacheEntry, CacheStats, ServerHealthResponse, ServerErrorResponse, BarcodeFormat, BarcodeData, BarcodeDetectionResult, UseMultiBarcodeScannerOptions, UseMultiBarcodeScannerReturn, BarcodeCacheEntry, ProductCategory, ProduceType, ProduceQuality, ProductData, ProductMatch, ProduceData, ProductDetectionResult, DetectionModel, UseProductDetectorOptions, UseProductDetectorReturn, TFLiteDetectionOutput, ClassLabelMap, TextLine, TextBlock, TextRecognitionResult, ReceiptItem, ReceiptMetadata, ReceiptScanResult, KnownStore, UseReceiptScannerOptions, UseReceiptScannerReturn, ReceiptLineType, ParsedReceiptLine, } from './types';
+export { GROCERY_BARCODE_FORMATS } from './types/barcode';
+export { MLVisionProvider, useMLVisionContext, useMLVisionReady, type MLVisionProviderProps, type MLVisionContextValue, CacheManager, createCacheManager, CACHE_TTL, type CachedBarcodeLookup, type CachedProductRecognition, ServerClient, createServerClient, ServerError, type ServerRequestOptions, type ImageUploadData, type DetectionRequestOptions, type OCRRequestOptions, } from './core';
+export { useProductDetector } from './hooks/useProductDetector';
+export { CLASS_LABELS, NUM_CLASSES, getClassInfo, getLabelsArray, CATEGORY_CLASSES, } from './hooks/classLabels';
+export { useMultiBarcodeScanner } from './hooks/useMultiBarcodeScanner';
+export { useReceiptScanner } from './hooks/useReceiptScanner';
+export { useVideoScanner, type ScanMode, type VideoScanResult, type UseVideoScannerOptions, type UseVideoScannerReturn, } from './hooks/useVideoScanner';
+export { DetectionOverlay, DetectionLoadingOverlay, type DetectionOverlayProps, } from './components';
+export { createDetectionProcessor, frameDetectionToResult, getClassLabel, type FrameDetection, type DetectionProcessorOptions, } from './processors';
+export { useTFLiteFrameProcessor, createTFLiteFrameProcessor, type TFLiteFrameDetection, type FrameProcessorResult, type UseTFLiteFrameProcessorOptions, } from './processors';
+export { preprocessImage, isSkiaAvailable, isResizePluginAvailable, getFrameProcessorInstructions, } from './utils/imagePreprocessor';
+export { processYoloOutput, scaleDetections, } from './utils/yoloProcessor';
+export { COCO_CLASSES, CLASS_LABELS_COCO, NUM_CLASSES_COCO, FOOD_CLASS_INDICES, getCocoClassInfo, isFoodClass, } from './hooks/classLabelsCoco';
+export declare const VERSION = "0.1.0";

package/dist/index.js

@@ -0,0 +1,130 @@
+"use strict";
+/**
+ * @souschef/ml-vision
+ *
+ * ML-powered product detection for React Native
+ *
+ * Features:
+ * - Multi-barcode scanning (scan multiple barcodes at once)
+ * - Receipt OCR (photograph receipts to extract items)
+ * - Visual product recognition (recognize fridge/pantry contents)
+ * - Video scanning (real-time product detection)
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   MLVisionProvider,
+ *   useMultiBarcodeScanner,
+ *   useProductDetector,
+ *   useReceiptScanner,
+ * } from '@souschef/ml-vision';
+ *
+ * // Wrap your app with the provider
+ * function App() {
+ *   return (
+ *     <MLVisionProvider
+ *       config={{ serverUrl: 'http://192.168.1.100:8000' }}
+ *       storage={mmkvInstance}
+ *     >
+ *       <YourApp />
+ *     </MLVisionProvider>
+ *   );
+ * }
+ *
+ * // Use hooks in your components
+ * function ScannerScreen() {
+ *   const { scanPhoto, results } = useMultiBarcodeScanner();
+ *   const { detectProducts, detections } = useProductDetector();
+ *
+ *   // ...
+ * }
+ * ```
+ *
+ * @packageDocumentation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VERSION = exports.isFoodClass = exports.getCocoClassInfo = exports.FOOD_CLASS_INDICES = exports.NUM_CLASSES_COCO = exports.CLASS_LABELS_COCO = exports.COCO_CLASSES = exports.scaleDetections = exports.processYoloOutput = exports.getFrameProcessorInstructions = exports.isResizePluginAvailable = exports.isSkiaAvailable = exports.preprocessImage = exports.createTFLiteFrameProcessor = exports.useTFLiteFrameProcessor = exports.getClassLabel = exports.frameDetectionToResult = exports.createDetectionProcessor = exports.DetectionLoadingOverlay = exports.DetectionOverlay = exports.useVideoScanner = exports.useReceiptScanner = exports.useMultiBarcodeScanner = exports.CATEGORY_CLASSES = exports.getLabelsArray = exports.getClassInfo = exports.NUM_CLASSES = exports.CLASS_LABELS = exports.useProductDetector = exports.ServerError = exports.createServerClient = exports.ServerClient = exports.CACHE_TTL = exports.createCacheManager = exports.CacheManager = exports.useMLVisionReady = exports.useMLVisionContext = exports.MLVisionProvider = exports.GROCERY_BARCODE_FORMATS = void 0;
+// Re-export barcode format constants
+var barcode_1 = require("./types/barcode");
+Object.defineProperty(exports, "GROCERY_BARCODE_FORMATS", { enumerable: true, get: function () { return barcode_1.GROCERY_BARCODE_FORMATS; } });
+// ============================================================================
+// Core - Provider, Cache, Server Client
+// ============================================================================
+var core_1 = require("./core");
+// Provider
+Object.defineProperty(exports, "MLVisionProvider", { enumerable: true, get: function () { return core_1.MLVisionProvider; } });
+Object.defineProperty(exports, "useMLVisionContext", { enumerable: true, get: function () { return core_1.useMLVisionContext; } });
+Object.defineProperty(exports, "useMLVisionReady", { enumerable: true, get: function () { return core_1.useMLVisionReady; } });
+// Cache
+Object.defineProperty(exports, "CacheManager", { enumerable: true, get: function () { return core_1.CacheManager; } });
+Object.defineProperty(exports, "createCacheManager", { enumerable: true, get: function () { return core_1.createCacheManager; } });
+Object.defineProperty(exports, "CACHE_TTL", { enumerable: true, get: function () { return core_1.CACHE_TTL; } });
+// Server Client
+Object.defineProperty(exports, "ServerClient", { enumerable: true, get: function () { return core_1.ServerClient; } });
+Object.defineProperty(exports, "createServerClient", { enumerable: true, get: function () { return core_1.createServerClient; } });
+Object.defineProperty(exports, "ServerError", { enumerable: true, get: function () { return core_1.ServerError; } });
+// ============================================================================
+// Hooks
+// ============================================================================
+// Phase 3: Visual product detection
+var useProductDetector_1 = require("./hooks/useProductDetector");
+Object.defineProperty(exports, "useProductDetector", { enumerable: true, get: function () { return useProductDetector_1.useProductDetector; } });
+var classLabels_1 = require("./hooks/classLabels");
+Object.defineProperty(exports, "CLASS_LABELS", { enumerable: true, get: function () { return classLabels_1.CLASS_LABELS; } });
+Object.defineProperty(exports, "NUM_CLASSES", { enumerable: true, get: function () { return classLabels_1.NUM_CLASSES; } });
+Object.defineProperty(exports, "getClassInfo", { enumerable: true, get: function () { return classLabels_1.getClassInfo; } });
+Object.defineProperty(exports, "getLabelsArray", { enumerable: true, get: function () { return classLabels_1.getLabelsArray; } });
+Object.defineProperty(exports, "CATEGORY_CLASSES", { enumerable: true, get: function () { return classLabels_1.CATEGORY_CLASSES; } });
+// Phase 5: Multi-barcode scanning
+var useMultiBarcodeScanner_1 = require("./hooks/useMultiBarcodeScanner");
+Object.defineProperty(exports, "useMultiBarcodeScanner", { enumerable: true, get: function () { return useMultiBarcodeScanner_1.useMultiBarcodeScanner; } });
+// Phase 6: Receipt OCR
+var useReceiptScanner_1 = require("./hooks/useReceiptScanner");
+Object.defineProperty(exports, "useReceiptScanner", { enumerable: true, get: function () { return useReceiptScanner_1.useReceiptScanner; } });
+// Phase 7: Video scanning
+var useVideoScanner_1 = require("./hooks/useVideoScanner");
+Object.defineProperty(exports, "useVideoScanner", { enumerable: true, get: function () { return useVideoScanner_1.useVideoScanner; } });
+// ============================================================================
+// Components
+// ============================================================================
+var components_1 = require("./components");
+Object.defineProperty(exports, "DetectionOverlay", { enumerable: true, get: function () { return components_1.DetectionOverlay; } });
+Object.defineProperty(exports, "DetectionLoadingOverlay", { enumerable: true, get: function () { return components_1.DetectionLoadingOverlay; } });
+// ============================================================================
+// Processors
+// ============================================================================
+var processors_1 = require("./processors");
+Object.defineProperty(exports, "createDetectionProcessor", { enumerable: true, get: function () { return processors_1.createDetectionProcessor; } });
+Object.defineProperty(exports, "frameDetectionToResult", { enumerable: true, get: function () { return processors_1.frameDetectionToResult; } });
+Object.defineProperty(exports, "getClassLabel", { enumerable: true, get: function () { return processors_1.getClassLabel; } });
+// TFLite Frame Processor for real-time video scanning
+var processors_2 = require("./processors");
+Object.defineProperty(exports, "useTFLiteFrameProcessor", { enumerable: true, get: function () { return processors_2.useTFLiteFrameProcessor; } });
+Object.defineProperty(exports, "createTFLiteFrameProcessor", { enumerable: true, get: function () { return processors_2.createTFLiteFrameProcessor; } });
+// ============================================================================
+// Utilities
+// ============================================================================
+// export { generateImageHash } from './utils/imageUtils';
+// export { parseReceiptText } from './utils/receiptParser';
+// Image preprocessing for on-device TFLite inference
+var imagePreprocessor_1 = require("./utils/imagePreprocessor");
+Object.defineProperty(exports, "preprocessImage", { enumerable: true, get: function () { return imagePreprocessor_1.preprocessImage; } });
+Object.defineProperty(exports, "isSkiaAvailable", { enumerable: true, get: function () { return imagePreprocessor_1.isSkiaAvailable; } });
+Object.defineProperty(exports, "isResizePluginAvailable", { enumerable: true, get: function () { return imagePreprocessor_1.isResizePluginAvailable; } });
+Object.defineProperty(exports, "getFrameProcessorInstructions", { enumerable: true, get: function () { return imagePreprocessor_1.getFrameProcessorInstructions; } });
+// YOLO output processing
+var yoloProcessor_1 = require("./utils/yoloProcessor");
+Object.defineProperty(exports, "processYoloOutput", { enumerable: true, get: function () { return yoloProcessor_1.processYoloOutput; } });
+Object.defineProperty(exports, "scaleDetections", { enumerable: true, get: function () { return yoloProcessor_1.scaleDetections; } });
+// COCO class labels (80 classes for general object detection)
+var classLabelsCoco_1 = require("./hooks/classLabelsCoco");
+Object.defineProperty(exports, "COCO_CLASSES", { enumerable: true, get: function () { return classLabelsCoco_1.COCO_CLASSES; } });
+Object.defineProperty(exports, "CLASS_LABELS_COCO", { enumerable: true, get: function () { return classLabelsCoco_1.CLASS_LABELS_COCO; } });
+Object.defineProperty(exports, "NUM_CLASSES_COCO", { enumerable: true, get: function () { return classLabelsCoco_1.NUM_CLASSES_COCO; } });
+Object.defineProperty(exports, "FOOD_CLASS_INDICES", { enumerable: true, get: function () { return classLabelsCoco_1.FOOD_CLASS_INDICES; } });
+Object.defineProperty(exports, "getCocoClassInfo", { enumerable: true, get: function () { return classLabelsCoco_1.getCocoClassInfo; } });
+Object.defineProperty(exports, "isFoodClass", { enumerable: true, get: function () { return classLabelsCoco_1.isFoodClass; } });
+// ============================================================================
+// Version
+// ============================================================================
+exports.VERSION = '0.1.0';

package/dist/processors/detectionProcessor.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Detection Frame Processor
+ *
+ * VisionCamera frame processor for real-time product detection.
+ * Uses react-native-fast-tflite for on-device inference.
+ *
+ * @example
+ * ```typescript
+ * import { useFrameProcessor } from 'react-native-vision-camera';
+ * import { detectProducts } from '@souschef/ml-vision/processors';
+ *
+ * function CameraScreen() {
+ *   const frameProcessor = useFrameProcessor((frame) => {
+ *     'worklet';
+ *     const detections = detectProducts(frame);
+ *     // Handle detections...
+ *   }, []);
+ *
+ *   return <Camera frameProcessor={frameProcessor} />;
+ * }
+ * ```
+ */
+import type { ProductDetectionResult } from '../types';
+import { CLASS_LABELS, NUM_CLASSES } from '../hooks/classLabels';
+/**
+ * Frame processor detection result (simplified for worklet)
+ */
+export interface FrameDetection {
+    /** Class index */
+    classIndex: number;
+    /** Class label */
+    label: string;
+    /** Confidence score 0-1 */
+    confidence: number;
+    /** Bounding box (normalized 0-1) */
+    box: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+}
+/**
+ * Frame processor options
+ */
+export interface DetectionProcessorOptions {
+    /** Minimum confidence threshold (default: 0.5) */
+    minConfidence?: number;
+    /** Maximum detections per frame (default: 10) */
+    maxDetections?: number;
+    /** Run every N frames (default: 3 for ~10fps at 30fps input) */
+    frameSkip?: number;
+    /** Class indices to detect (default: all) */
+    classFilter?: number[];
+}
+/**
+ * Create a detection frame processor
+ *
+ * This returns a function that can be used with VisionCamera's useFrameProcessor.
+ *
+ * @example
+ * ```typescript
+ * const detectFrame = createDetectionProcessor({
+ *   minConfidence: 0.5,
+ *   maxDetections: 10,
+ * });
+ *
+ * const frameProcessor = useFrameProcessor((frame) => {
+ *   'worklet';
+ *   const detections = detectFrame(frame);
+ *   runOnJS(handleDetections)(detections);
+ * }, []);
+ * ```
+ */
+export declare function createDetectionProcessor(options?: DetectionProcessorOptions): (_frame: unknown) => FrameDetection[];
+/**
+ * Convert FrameDetection to ProductDetectionResult
+ *
+ * Call this on the JS thread after receiving worklet results.
+ */
+export declare function frameDetectionToResult(detection: FrameDetection, imageWidth: number, imageHeight: number): ProductDetectionResult;
+/**
+ * Get label for class index (can be called from worklet via shared value)
+ */
+export declare function getClassLabel(classIndex: number): string;
+export { NUM_CLASSES, CLASS_LABELS };