@hexar/biometric-identity-sdk-core 1.0.0

package/src/validation/OCREngine.ts

@@ -0,0 +1,265 @@
+/**
+ * OCR Engine for extracting data from ID documents
+ */
+
+import { DocumentData } from '../types';
+
+export interface OCRResult {
+  text: string;
+  confidence: number;
+  boundingBox?: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+  };
+}
+
+export class OCREngine {
+  private tesseract: any;
+  private isInitialized: boolean = false;
+
+  constructor() {}
+
+  /**
+   * Initialize OCR engine
+   */
+  async initialize(): Promise<void> {
+    if (this.isInitialized) return;
+
+    try {
+      console.log('Initializing OCR engine...');
+      
+      // In real implementation, would initialize Tesseract.js
+      // await createWorker();
+      
+      await new Promise(resolve => setTimeout(resolve, 500));
+      
+      this.isInitialized = true;
+      console.log('OCR engine initialized successfully');
+    } catch (error) {
+      throw new Error(`Failed to initialize OCR engine: ${error}`);
+    }
+  }
+
+  /**
+   * Extract text from document image
+   */
+  async extractText(imageData: string | Buffer): Promise<OCRResult[]> {
+    if (!this.isInitialized) {
+      await this.initialize();
+    }
+
+    try {
+      // In real implementation:
+      // const result = await this.tesseract.recognize(imageData);
+      // return result.data.words;
+
+      // Mock implementation
+      return this.mockOCRResults();
+    } catch (error) {
+      throw new Error(`OCR extraction failed: ${error}`);
+    }
+  }
+
+  /**
+   * Extract structured data from ID document
+   */
+  async extractDocumentData(
+    frontImage: string | Buffer,
+    backImage?: string | Buffer
+  ): Promise<DocumentData> {
+    if (!this.isInitialized) {
+      await this.initialize();
+    }
+
+    try {
+      // Extract text from front
+      const frontText = await this.extractText(frontImage);
+      const frontRawText = frontText.map(r => r.text).join(' ');
+
+      // Extract text from back (if provided)
+      let backRawText = '';
+      if (backImage) {
+        const backText = await this.extractText(backImage);
+        backRawText = backText.map(r => r.text).join(' ');
+      }
+
+      // Parse structured data
+      const documentData = this.parseDocumentData(frontRawText, backRawText);
+
+      return documentData;
+    } catch (error) {
+      throw new Error(`Document data extraction failed: ${error}`);
+    }
+  }
+
+  /**
+   * Parse raw OCR text into structured document data
+   */
+  private parseDocumentData(frontText: string, backText: string): DocumentData {
+    // In real implementation:
+    // 1. Use regex patterns for different document types
+    // 2. Apply NLP for field extraction
+    // 3. Validate extracted data format
+    // 4. Handle multiple languages
+
+    // Mock implementation with realistic patterns
+    const firstName = this.extractField(frontText, /(?:Given\s+Name|First\s+Name|Nombre)[:\s]+([A-Z][a-z]+)/i) || 'John';
+    const lastName = this.extractField(frontText, /(?:Surname|Last\s+Name|Apellido)[:\s]+([A-Z][a-z]+)/i) || 'Doe';
+    const documentNumber = this.extractField(frontText, /(?:ID|Document)\s*(?:No|Number|#)[:\s]*([A-Z0-9]{6,12})/i) || this.generateMockDocNumber();
+    const dateOfBirth = this.extractDate(frontText, /(?:Date\s+of\s+Birth|DOB|Fecha\s+de\s+Nacimiento)[:\s]*([\d\/\-\.]+)/i) || '1990-01-15';
+    const expirationDate = this.extractDate(frontText, /(?:Expir(?:y|ation)|Valid\s+Until)[:\s]*([\d\/\-\.]+)/i) || this.generateExpirationDate();
+    const nationality = this.extractField(frontText, /(?:Nationality|Nacionalidad)[:\s]+([A-Z]{2,20})/i) || 'USA';
+
+    return {
+      firstName,
+      lastName,
+      documentNumber,
+      dateOfBirth,
+      expirationDate,
+      nationality,
+      documentType: 'national_id',
+      gender: this.extractGender(frontText),
+      rawText: frontText + ' ' + backText,
+    };
+  }
+
+  /**
+   * Extract field from text using regex
+   */
+  private extractField(text: string, pattern: RegExp): string | null {
+    const match = text.match(pattern);
+    return match ? match[1].trim() : null;
+  }
+
+  /**
+   * Extract and format date from text
+   */
+  private extractDate(text: string, pattern: RegExp): string | null {
+    const match = text.match(pattern);
+    if (!match) return null;
+
+    const dateStr = match[1].trim();
+    
+    // Try to parse date
+    try {
+      // Handle various date formats: DD/MM/YYYY, MM-DD-YYYY, DD.MM.YYYY, etc.
+      const parts = dateStr.split(/[\-\/\.]/);
+      
+      if (parts.length === 3) {
+        // Assume DD/MM/YYYY or MM/DD/YYYY
+        let day, month, year;
+        
+        if (parseInt(parts[0]) > 12) {
+          // DD/MM/YYYY
+          day = parts[0].padStart(2, '0');
+          month = parts[1].padStart(2, '0');
+          year = parts[2];
+        } else {
+          // MM/DD/YYYY
+          month = parts[0].padStart(2, '0');
+          day = parts[1].padStart(2, '0');
+          year = parts[2];
+        }
+
+        return `${year}-${month}-${day}`;
+      }
+    } catch {
+      return dateStr;
+    }
+
+    return dateStr;
+  }
+
+  /**
+   * Extract gender from text
+   */
+  private extractGender(text: string): string | undefined {
+    const match = text.match(/(?:Sex|Gender|Sexo)[:\s]*([MF])/i);
+    if (match) {
+      return match[1].toUpperCase() === 'M' ? 'Male' : 'Female';
+    }
+    return undefined;
+  }
+
+  /**
+   * Generate mock document number
+   */
+  private generateMockDocNumber(): string {
+    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
+    let result = '';
+    for (let i = 0; i < 9; i++) {
+      result += chars.charAt(Math.floor(Math.random() * chars.length));
+    }
+    return result;
+  }
+
+  /**
+   * Generate mock expiration date (2-5 years from now)
+   */
+  private generateExpirationDate(): string {
+    const date = new Date();
+    date.setFullYear(date.getFullYear() + 2 + Math.floor(Math.random() * 3));
+    return date.toISOString().split('T')[0];
+  }
+
+  /**
+   * Mock OCR results
+   */
+  private mockOCRResults(): OCRResult[] {
+    return [
+      { text: 'UNITED STATES OF AMERICA', confidence: 0.95 },
+      { text: 'Driver License', confidence: 0.92 },
+      { text: 'First Name: JOHN', confidence: 0.88 },
+      { text: 'Last Name: DOE', confidence: 0.90 },
+      { text: 'DOB: 01/15/1990', confidence: 0.87 },
+      { text: 'Document No: DL123456789', confidence: 0.85 },
+      { text: 'Expiration: 12/31/2026', confidence: 0.89 },
+      { text: 'Nationality: USA', confidence: 0.93 },
+    ];
+  }
+
+  /**
+   * Validate extracted document number format
+   */
+  validateDocumentNumber(documentNumber: string, documentType: string): boolean {
+    // In real implementation, validate format based on document type and country
+    
+    if (!documentNumber || documentNumber.length < 6) return false;
+    
+    // Basic alphanumeric check
+    return /^[A-Z0-9]{6,15}$/i.test(documentNumber);
+  }
+
+  /**
+   * Clean up resources
+   */
+  async dispose(): Promise<void> {
+    if (this.tesseract) {
+      // await this.tesseract.terminate();
+      this.tesseract = null;
+    }
+    this.isInitialized = false;
+  }
+}
+
+/**
+ * Clean and normalize extracted text
+ */
+export function cleanText(text: string): string {
+  return text
+    .replace(/[^\w\s\-\/\.\:]/g, '') // Remove special characters
+    .replace(/\s+/g, ' ') // Normalize whitespace
+    .trim();
+}
+
+/**
+ * Validate date format
+ */
+export function isValidDate(dateString: string): boolean {
+  const date = new Date(dateString);
+  return date instanceof Date && !isNaN(date.getTime());
+}
+
+

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "lib": ["ES2020"],
+    "declaration": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "moduleResolution": "node"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}
+
+