mediversal-rn-image-intelligence 1.0.6

package/package.json

@@ -0,0 +1,157 @@
+{
+  "name": "mediversal-rn-image-intelligence",
+  "version": "1.0.6",
+  "description": "Production-ready React Native library for intelligent image analysis using Google ML Kit (on-device)",
+  "main": "lib/commonjs/index.js",
+  "module": "lib/module/index.js",
+  "types": "lib/typescript/index.d.ts",
+  "react-native": "src/index.tsx",
+  "source": "src/index.tsx",
+  "files": [
+    "src",
+    "lib",
+    "android",
+    "ios",
+    "cpp",
+    "mediversal-rn-image-intelligence.podspec",
+    "!lib/typescript/example",
+    "!android/build",
+    "!ios/build",
+    "!**/__tests__",
+    "!**/__fixtures__",
+    "!**/__mocks__"
+  ],
+  "scripts": {
+    "test": "jest",
+    "typescript": "tsc --noEmit",
+    "lint": "eslint \"**/*.{js,ts,tsx}\"",
+    "prepare": "bob build",
+    "release": "release-it",
+    "example": "yarn --cwd example",
+    "pods": "cd example && pod-install --quiet",
+    "bootstrap": "yarn example && yarn && yarn pods"
+  },
+  "keywords": [
+    "react-native",
+    "ios",
+    "android",
+    "ml-kit",
+    "google-ml-kit",
+    "face-detection",
+    "text-recognition",
+    "ocr",
+    "handwriting-recognition",
+    "image-analysis",
+    "computer-vision",
+    "turbomodule"
+  ],
+  "repository": "https://github.com/mediversal/mediversal-rn-image-intelligence",
+  "author": "Mediversal <dev@mediversal.com> (https://mediversal.com)",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/mediversal/mediversal-rn-image-intelligence/issues"
+  },
+  "homepage": "https://github.com/mediversal/mediversal-rn-image-intelligence#readme",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  },
+  "devDependencies": {
+    "@babel/preset-typescript": "^7.28.5",
+    "@react-native-community/eslint-config": "^3.0.0",
+    "@types/jest": "^28.1.2",
+    "@types/react": "~17.0.21",
+    "@types/react-native": "0.70.0",
+    "eslint": "^8.4.1",
+    "eslint-config-prettier": "^8.5.0",
+    "eslint-plugin-prettier": "^4.0.0",
+    "jest": "^28.1.1",
+    "pod-install": "^0.1.0",
+    "prettier": "^2.0.5",
+    "react": "18.2.0",
+    "react-native": "0.72.0",
+    "react-native-builder-bob": "^0.20.0",
+    "release-it": "^15.0.0",
+    "typescript": "^4.5.2"
+  },
+  "peerDependencies": {
+    "react": "*",
+    "react-native": "*"
+  },
+  "jest": {
+    "preset": "react-native",
+    "moduleFileExtensions": [
+      "ts",
+      "tsx",
+      "js",
+      "jsx",
+      "json",
+      "node"
+    ],
+    "transformIgnorePatterns": [
+      "node_modules/(?!((jest-)?react-native|@react-native|@react-native-community|@react-native-js-polyfills)/)"
+    ],
+    "setupFiles": [
+      "<rootDir>/jest.setup.js"
+    ]
+  },
+  "eslintConfig": {
+    "root": true,
+    "parser": "@typescript-eslint/parser",
+    "parserOptions": {
+      "ecmaVersion": 2020,
+      "sourceType": "module",
+      "ecmaFeatures": {
+        "jsx": true
+      }
+    },
+    "plugins": [
+      "@typescript-eslint"
+    ],
+    "extends": [
+      "@react-native-community",
+      "prettier",
+      "plugin:@typescript-eslint/recommended"
+    ],
+    "rules": {
+      "prettier/prettier": [
+        "error",
+        {
+          "quoteProps": "consistent",
+          "singleQuote": true,
+          "tabWidth": 2,
+          "trailingComma": "es5",
+          "useTabs": false
+        }
+      ]
+    },
+    "ignorePatterns": [
+      "node_modules/",
+      "lib/"
+    ]
+  },
+  "eslintIgnore": [
+    "node_modules/",
+    "lib/"
+  ],
+  "prettier": {
+    "quoteProps": "consistent",
+    "singleQuote": true,
+    "tabWidth": 2,
+    "trailingComma": "es5",
+    "useTabs": false
+  },
+  "react-native-builder-bob": {
+    "source": "src",
+    "output": "lib",
+    "targets": [
+      "commonjs",
+      "module",
+      [
+        "typescript",
+        {
+          "project": "tsconfig.build.json"
+        }
+      ]
+    ]
+  }
+}

package/src/NativeFaceDetectionModule.ts

@@ -0,0 +1,18 @@
+import type { TurboModule } from 'react-native';
+import { TurboModuleRegistry } from 'react-native';
+import type { NativeFaceDetectionResult } from './types';
+
+/**
+ * Face Detection TurboModule Specification
+ */
+export interface Spec extends TurboModule {
+  detectFaces(
+    imageUri: string,
+    mode: string,
+    minFaceSize: number
+  ): Promise<NativeFaceDetectionResult>;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>(
+  'FaceDetectionModule'
+) as Spec;

package/src/NativeHandwritingRecognitionModule.ts

@@ -0,0 +1,16 @@
+import type { TurboModule } from 'react-native';
+import { TurboModuleRegistry } from 'react-native';
+import type { NativeHandwritingRecognitionResult } from './types';
+
+/**
+ * Handwriting Recognition TurboModule Specification
+ */
+export interface Spec extends TurboModule {
+  recognizeHandwriting(
+    imageUri: string
+  ): Promise<NativeHandwritingRecognitionResult>;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>(
+  'HandwritingRecognitionModule'
+) as Spec;

package/src/NativeTextRecognitionModule.ts

@@ -0,0 +1,14 @@
+import type { TurboModule } from 'react-native';
+import { TurboModuleRegistry } from 'react-native';
+import type { NativeTextRecognitionResult } from './types';
+
+/**
+ * Text Recognition TurboModule Specification
+ */
+export interface Spec extends TurboModule {
+  recognizeText(imageUri: string): Promise<NativeTextRecognitionResult>;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>(
+  'TextRecognitionModule'
+) as Spec;

package/src/index.tsx

@@ -0,0 +1,243 @@
+import { Platform } from 'react-native';
+import FaceDetectionModule from './NativeFaceDetectionModule';
+import TextRecognitionModule from './NativeTextRecognitionModule';
+import HandwritingRecognitionModule from './NativeHandwritingRecognitionModule';
+import type { AnalysisResult, AnalysisOptions } from './types';
+
+// Export types for consumers
+export type {
+  AnalysisResult,
+  AnalysisOptions,
+  FaceData,
+  BoundingBox,
+} from './types';
+
+/**
+ * Default analysis options
+ */
+const DEFAULT_OPTIONS: Required<AnalysisOptions> = {
+  detectFaces: true,
+  detectPrintedText: true,
+  detectHandwrittenText: true,
+  faceDetectionMode: 'fast',
+  minFaceSize: 0.1,
+};
+
+/**
+ * Validates and normalizes the image URI
+ * @param imageUri - The image URI to validate
+ * @returns Normalized URI
+ * @throws Error if URI is invalid
+ */
+function validateImageUri(imageUri: string): string {
+  if (!imageUri || typeof imageUri !== 'string') {
+    throw new Error('Invalid image URI: must be a non-empty string');
+  }
+
+  const trimmedUri = imageUri.trim();
+
+  if (trimmedUri.length === 0) {
+    throw new Error('Invalid image URI: must be a non-empty string');
+  }
+
+  // Validate URI format
+  if (Platform.OS === 'android') {
+    // Android accepts: file://, content://, or absolute paths
+    if (
+      !trimmedUri.startsWith('file://') &&
+      !trimmedUri.startsWith('content://') &&
+      !trimmedUri.startsWith('/')
+    ) {
+      throw new Error(
+        'Invalid Android image URI: must start with file://, content://, or be an absolute path'
+      );
+    }
+  } else if (Platform.OS === 'ios') {
+    // iOS accepts: file://, ph://, assets-library://, or absolute paths
+    if (
+      !trimmedUri.startsWith('file://') &&
+      !trimmedUri.startsWith('ph://') &&
+      !trimmedUri.startsWith('assets-library://') &&
+      !trimmedUri.startsWith('/')
+    ) {
+      throw new Error(
+        'Invalid iOS image URI: must start with file://, ph://, assets-library://, or be an absolute path'
+      );
+    }
+  }
+
+  return trimmedUri;
+}
+
+/**
+ * Analyzes an image using Google ML Kit on-device APIs
+ *
+ * This function performs parallel analysis using three ML Kit models:
+ * - Face Detection: Detects human faces and facial attributes
+ * - Text Recognition: Extracts printed text (OCR)
+ * - Digital Ink Recognition: Extracts handwritten text
+ *
+ * @param imageUri - Local file URI (e.g., "file:///path/to/image.jpg", "content://...", or absolute path)
+ * @param options - Configuration options for the analysis
+ * @returns Promise resolving to the analysis result
+ *
+ * @example
+ * ```typescript
+ * const result = await analyzeImage('file:///path/to/image.jpg');
+ *
+ * if (result.containsFace) {
+ *   console.log(`Found ${result.faces?.length} face(s)`);
+ *   result.faces?.forEach(face => {
+ *     console.log('Smiling:', face.smilingProbability);
+ *   });
+ * }
+ *
+ * if (result.containsPrintedText) {
+ *   console.log('Text:', result.printedText);
+ * }
+ * ```
+ *
+ * @throws Error if imageUri is invalid or if all analyses fail
+ */
+export async function analyzeImage(
+  imageUri: string,
+  options: AnalysisOptions = {}
+): Promise<AnalysisResult> {
+  // Validate input
+  const validatedUri = validateImageUri(imageUri);
+
+  // Merge with default options
+  const opts: Required<AnalysisOptions> = {
+    ...DEFAULT_OPTIONS,
+    ...options,
+  };
+
+  // Initialize result
+  const result: AnalysisResult = {
+    containsFace: false,
+    containsPrintedText: false,
+    containsHandwrittenText: false,
+  };
+
+  // Create promises array for parallel execution
+  const promises: Promise<void>[] = [];
+
+  // Face Detection
+  if (opts.detectFaces) {
+    promises.push(
+      (async () => {
+        try {
+          const faceResult = await FaceDetectionModule.detectFaces(
+            validatedUri,
+            opts.faceDetectionMode,
+            opts.minFaceSize
+          );
+
+          if (faceResult.error) {
+            result.errors = result.errors || {};
+            result.errors.faceDetection = faceResult.error;
+          } else if (faceResult.faces && faceResult.faces.length > 0) {
+            result.containsFace = true;
+            result.faces = faceResult.faces;
+          }
+        } catch (error) {
+          result.errors = result.errors || {};
+          result.errors.faceDetection =
+            error instanceof Error ? error.message : 'Unknown error';
+        }
+      })()
+    );
+  }
+
+  // Text Recognition (Printed)
+  if (opts.detectPrintedText) {
+    promises.push(
+      (async () => {
+        try {
+          const textResult = await TextRecognitionModule.recognizeText(
+            validatedUri
+          );
+
+          if (textResult.error) {
+            result.errors = result.errors || {};
+            result.errors.textRecognition = textResult.error;
+          } else if (textResult.text && textResult.text.trim().length > 0) {
+            result.containsPrintedText = true;
+            result.printedText = textResult.text;
+          }
+        } catch (error) {
+          result.errors = result.errors || {};
+          result.errors.textRecognition =
+            error instanceof Error ? error.message : 'Unknown error';
+        }
+      })()
+    );
+  }
+
+  // Handwriting Recognition
+  if (opts.detectHandwrittenText) {
+    promises.push(
+      (async () => {
+        try {
+          const handwritingResult =
+            await HandwritingRecognitionModule.recognizeHandwriting(
+              validatedUri
+            );
+
+          if (handwritingResult.error) {
+            result.errors = result.errors || {};
+            result.errors.handwritingRecognition = handwritingResult.error;
+          } else if (
+            handwritingResult.text &&
+            handwritingResult.text.trim().length > 0
+          ) {
+            result.containsHandwrittenText = true;
+            result.handwrittenText = handwritingResult.text;
+          }
+        } catch (error) {
+          result.errors = result.errors || {};
+          result.errors.handwritingRecognition =
+            error instanceof Error ? error.message : 'Unknown error';
+        }
+      })()
+    );
+  }
+
+  // Wait for all analyses to complete
+  await Promise.all(promises);
+
+  // If all enabled analyses failed, throw an error
+  const enabledCount = promises.length;
+  const errorCount = result.errors ? Object.keys(result.errors).length : 0;
+
+  if (enabledCount > 0 && errorCount === enabledCount) {
+    throw new Error(
+      `All image analyses failed: ${JSON.stringify(result.errors)}`
+    );
+  }
+
+  return result;
+}
+
+/**
+ * Check if the library is properly installed and native modules are available
+ * @returns Promise resolving to true if all modules are available
+ */
+export async function isAvailable(): Promise<boolean> {
+  try {
+    // Simple check - all modules should be available
+    return !!(
+      FaceDetectionModule &&
+      TextRecognitionModule &&
+      HandwritingRecognitionModule
+    );
+  } catch {
+    return false;
+  }
+}
+
+// Default export for convenience
+export default {
+  analyzeImage,
+  isAvailable,
+};

package/src/types.ts

@@ -0,0 +1,96 @@
+/**
+ * Bounding box coordinates and dimensions
+ */
+export interface BoundingBox {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}
+
+/**
+ * Face detection result with metadata
+ */
+export interface FaceData {
+  /** Bounding box of the detected face */
+  boundingBox: BoundingBox;
+  /** Probability that the face is smiling (0.0 to 1.0) */
+  smilingProbability?: number;
+  /** Probability that the left eye is open (0.0 to 1.0) */
+  leftEyeOpenProbability?: number;
+  /** Probability that the right eye is open (0.0 to 1.0) */
+  rightEyeOpenProbability?: number;
+  /** Head rotation around Y-axis (yaw) in degrees */
+  headEulerAngleY?: number;
+  /** Head rotation around Z-axis (roll) in degrees */
+  headEulerAngleZ?: number;
+  /** Tracking ID for video sequences */
+  trackingId?: number;
+}
+
+/**
+ * Complete analysis result from image intelligence
+ */
+export interface AnalysisResult {
+  /** True if at least one human face was detected */
+  containsFace: boolean;
+  /** True if printed text was detected */
+  containsPrintedText: boolean;
+  /** True if handwritten text was detected */
+  containsHandwrittenText: boolean;
+  /** Array of detected faces with metadata */
+  faces?: FaceData[];
+  /** Extracted printed text content */
+  printedText?: string;
+  /** Extracted handwritten text content */
+  handwrittenText?: string;
+  /** Error messages if any module failed (won't throw, for graceful degradation) */
+  errors?: {
+    faceDetection?: string;
+    textRecognition?: string;
+    handwritingRecognition?: string;
+  };
+}
+
+/**
+ * Configuration options for image analysis
+ */
+export interface AnalysisOptions {
+  /** Enable face detection (default: true) */
+  detectFaces?: boolean;
+  /** Enable printed text recognition (default: true) */
+  detectPrintedText?: boolean;
+  /** Enable handwritten text recognition (default: true) */
+  detectHandwrittenText?: boolean;
+  /** Face detection performance mode: 'fast' or 'accurate' (default: 'fast') */
+  faceDetectionMode?: 'fast' | 'accurate';
+  /** Minimum face size relative to image (0.0 to 1.0, default: 0.1) */
+  minFaceSize?: number;
+}
+
+/**
+ * Internal face detection result from native module
+ * @internal
+ */
+export interface NativeFaceDetectionResult {
+  faces: FaceData[];
+  error?: string;
+}
+
+/**
+ * Internal text recognition result from native module
+ * @internal
+ */
+export interface NativeTextRecognitionResult {
+  text: string;
+  error?: string;
+}
+
+/**
+ * Internal handwriting recognition result from native module
+ * @internal
+ */
+export interface NativeHandwritingRecognitionResult {
+  text: string;
+  error?: string;
+}