@hexar/biometric-identity-sdk-core 1.0.0

package/dist/validation/DocumentValidator.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Document Validation - Detect tampering, quality issues, and authenticity
+ */
+import { DocumentValidationResult } from '../types';
+export declare class DocumentValidator {
+    private modelPath?;
+    private model;
+    private isModelLoaded;
+    constructor(modelPath?: string | undefined);
+    /**
+     * Load document validation models
+     */
+    loadModel(): Promise<void>;
+    /**
+     * Validate document authenticity and quality
+     */
+    validateDocument(imageData: string | Buffer): Promise<DocumentValidationResult>;
+    /**
+     * Check document image quality
+     */
+    private checkQuality;
+    /**
+     * Detect glare in document image
+     */
+    private detectGlare;
+    /**
+     * Detect blur in document image
+     */
+    private detectBlur;
+    /**
+     * Detect if document is cropped
+     */
+    private detectCropping;
+    /**
+     * Detect reflections on document
+     */
+    private detectReflections;
+    /**
+     * Calculate edge detection score
+     */
+    private calculateEdgeScore;
+    /**
+     * Detect document tampering
+     */
+    private detectTampering;
+    /**
+     * Calculate tampering score
+     */
+    private calculateTamperScore;
+    /**
+     * Find suspicious regions in document
+     */
+    private findSuspiciousRegions;
+    /**
+     * Detect hologram on document
+     */
+    private detectHologram;
+    /**
+     * Calculate overall authenticity score
+     */
+    private calculateAuthenticityScore;
+    /**
+     * Detect document type (passport, ID card, driver's license, etc.)
+     */
+    detectDocumentType(imageData: string | Buffer): Promise<string>;
+    /**
+     * Validate document expiration
+     */
+    validateExpiration(expirationDate: string): boolean;
+    /**
+     * Clean up resources
+     */
+    dispose(): void;
+}
+/**
+ * Validate document meets minimum quality standards
+ */
+export declare function meetsQualityStandards(quality: {
+    hasGlare: boolean;
+    hasBlur: boolean;
+    hasCropping: boolean;
+    hasReflections: boolean;
+    edgeScore: number;
+}): boolean;

package/dist/validation/DocumentValidator.js

@@ -0,0 +1,295 @@
+"use strict";
+/**
+ * Document Validation - Detect tampering, quality issues, and authenticity
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DocumentValidator = void 0;
+exports.meetsQualityStandards = meetsQualityStandards;
+class DocumentValidator {
+    constructor(modelPath) {
+        this.modelPath = modelPath;
+        this.isModelLoaded = false;
+    }
+    /**
+     * Load document validation models
+     */
+    async loadModel() {
+        if (this.isModelLoaded)
+            return;
+        try {
+            console.log('Loading document validation model...');
+            // Simulate model loading
+            await new Promise(resolve => setTimeout(resolve, 300));
+            this.isModelLoaded = true;
+            console.log('Document validation model loaded successfully');
+        }
+        catch (error) {
+            throw new Error(`Failed to load document validation model: ${error}`);
+        }
+    }
+    /**
+     * Validate document authenticity and quality
+     */
+    async validateDocument(imageData) {
+        if (!this.isModelLoaded) {
+            await this.loadModel();
+        }
+        try {
+            // Perform parallel quality checks
+            const [qualityResult, tamperResult, hologramResult] = await Promise.all([
+                this.checkQuality(imageData),
+                this.detectTampering(imageData),
+                this.detectHologram(imageData),
+            ]);
+            // Calculate overall authenticity score
+            const authenticityScore = this.calculateAuthenticityScore(qualityResult, tamperResult, hologramResult);
+            const isAuthentic = authenticityScore >= 70 && !tamperResult.detected;
+            return {
+                isAuthentic,
+                authenticityScore,
+                quality: qualityResult,
+                tamper: tamperResult,
+                hologram: hologramResult,
+            };
+        }
+        catch (error) {
+            throw new Error(`Document validation failed: ${error}`);
+        }
+    }
+    /**
+     * Check document image quality
+     */
+    async checkQuality(imageData) {
+        // In real implementation:
+        // 1. Detect bright spots (glare)
+        // 2. Calculate blur metric (Laplacian variance)
+        // 3. Detect document edges and check if complete
+        // 4. Detect reflective areas
+        const hasGlare = await this.detectGlare(imageData);
+        const hasBlur = await this.detectBlur(imageData);
+        const hasCropping = await this.detectCropping(imageData);
+        const hasReflections = await this.detectReflections(imageData);
+        const edgeScore = await this.calculateEdgeScore(imageData);
+        return {
+            hasGlare,
+            hasBlur,
+            hasCropping,
+            hasReflections,
+            edgeScore,
+        };
+    }
+    /**
+     * Detect glare in document image
+     */
+    async detectGlare(imageData) {
+        // In real implementation:
+        // 1. Convert to grayscale
+        // 2. Find pixels above high threshold (> 240)
+        // 3. Calculate percentage of bright pixels
+        // 4. Check if bright regions form patches (glare patterns)
+        // Mock implementation
+        const randomScore = Math.random();
+        return randomScore < 0.15; // 15% chance of glare
+    }
+    /**
+     * Detect blur in document image
+     */
+    async detectBlur(imageData) {
+        // In real implementation:
+        // 1. Apply Laplacian operator
+        // 2. Calculate variance of Laplacian
+        // 3. Low variance indicates blur
+        // Mock implementation
+        const randomScore = Math.random();
+        return randomScore < 0.10; // 10% chance of blur
+    }
+    /**
+     * Detect if document is cropped
+     */
+    async detectCropping(imageData) {
+        // In real implementation:
+        // 1. Detect document edges using Canny edge detection
+        // 2. Find document contours
+        // 3. Check if all four corners are visible
+        // Mock implementation
+        const randomScore = Math.random();
+        return randomScore < 0.08; // 8% chance of cropping
+    }
+    /**
+     * Detect reflections on document
+     */
+    async detectReflections(imageData) {
+        // In real implementation:
+        // 1. Analyze specular highlights
+        // 2. Detect glossy surface patterns
+        // 3. Check for uneven lighting
+        // Mock implementation
+        const randomScore = Math.random();
+        return randomScore < 0.12; // 12% chance of reflections
+    }
+    /**
+     * Calculate edge detection score
+     */
+    async calculateEdgeScore(imageData) {
+        // In real implementation:
+        // 1. Apply Canny edge detection
+        // 2. Calculate edge pixel density
+        // 3. Normalize to 0-100 scale
+        // Mock implementation - random score between 70-98
+        return Math.round(70 + Math.random() * 28);
+    }
+    /**
+     * Detect document tampering
+     */
+    async detectTampering(imageData) {
+        // In real implementation:
+        // 1. Error Level Analysis (ELA)
+        // 2. Clone detection
+        // 3. JPEG artifact analysis
+        // 4. Metadata analysis
+        // 5. Font consistency check
+        // 6. Color histogram analysis
+        const tamperScore = await this.calculateTamperScore(imageData);
+        const suspiciousRegions = await this.findSuspiciousRegions(imageData);
+        return {
+            detected: tamperScore > 60,
+            score: tamperScore,
+            regions: suspiciousRegions,
+        };
+    }
+    /**
+     * Calculate tampering score
+     */
+    async calculateTamperScore(imageData) {
+        // In real implementation:
+        // 1. Analyze compression artifacts
+        // 2. Check for inconsistent noise patterns
+        // 3. Detect copy-paste regions
+        // 4. Validate text rendering consistency
+        // Mock implementation - most documents are authentic
+        const randomScore = Math.random();
+        return randomScore < 0.95 ? Math.round(Math.random() * 30) : Math.round(60 + Math.random() * 40);
+    }
+    /**
+     * Find suspicious regions in document
+     */
+    async findSuspiciousRegions(imageData) {
+        // In real implementation:
+        // 1. Apply ELA and find high-error regions
+        // 2. Detect cloned regions
+        // 3. Find inconsistent JPEG blocks
+        // Mock implementation - usually no suspicious regions
+        const randomScore = Math.random();
+        if (randomScore < 0.95) {
+            return [];
+        }
+        // Return 1-2 suspicious regions
+        return [
+            {
+                x: Math.round(Math.random() * 200),
+                y: Math.round(Math.random() * 100),
+                width: 50 + Math.round(Math.random() * 100),
+                height: 30 + Math.round(Math.random() * 50),
+            },
+        ];
+    }
+    /**
+     * Detect hologram on document
+     */
+    async detectHologram(imageData) {
+        // In real implementation:
+        // 1. Detect rainbow color patterns
+        // 2. Analyze light reflection patterns
+        // 3. Check for 3D effects
+        // 4. Validate hologram location on document
+        // Mock implementation
+        const randomScore = Math.random();
+        if (randomScore > 0.3) {
+            return {
+                detected: true,
+                confidence: 75 + Math.round(Math.random() * 20),
+            };
+        }
+        return {
+            detected: false,
+            confidence: Math.round(Math.random() * 50),
+        };
+    }
+    /**
+     * Calculate overall authenticity score
+     */
+    calculateAuthenticityScore(quality, tamper, hologram) {
+        let score = 100;
+        // Deduct points for quality issues
+        if (quality.hasGlare)
+            score -= 15;
+        if (quality.hasBlur)
+            score -= 20;
+        if (quality.hasCropping)
+            score -= 25;
+        if (quality.hasReflections)
+            score -= 10;
+        // Edge score impact
+        if (quality.edgeScore < 70)
+            score -= 15;
+        else if (quality.edgeScore < 80)
+            score -= 10;
+        // Tampering severely impacts score
+        if (tamper.detected) {
+            score -= 40;
+        }
+        else {
+            score -= Math.round(tamper.score * 0.3);
+        }
+        // Hologram bonus (if detected and confident)
+        if (hologram?.detected && hologram.confidence > 70) {
+            score = Math.min(100, score + 5);
+        }
+        return Math.max(0, Math.round(score));
+    }
+    /**
+     * Detect document type (passport, ID card, driver's license, etc.)
+     */
+    async detectDocumentType(imageData) {
+        // In real implementation:
+        // 1. Use template matching
+        // 2. Detect document layout patterns
+        // 3. OCR specific regions to identify type
+        // Mock implementation
+        const types = ['passport', 'national_id', 'drivers_license'];
+        return types[Math.floor(Math.random() * types.length)];
+    }
+    /**
+     * Validate document expiration
+     */
+    validateExpiration(expirationDate) {
+        try {
+            const expiry = new Date(expirationDate);
+            const now = new Date();
+            return expiry > now;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Clean up resources
+     */
+    dispose() {
+        this.model = null;
+        this.isModelLoaded = false;
+    }
+}
+exports.DocumentValidator = DocumentValidator;
+/**
+ * Validate document meets minimum quality standards
+ */
+function meetsQualityStandards(quality) {
+    if (quality.hasBlur || quality.hasCropping)
+        return false;
+    if (quality.hasGlare && quality.hasReflections)
+        return false;
+    if (quality.edgeScore < 60)
+        return false;
+    return true;
+}

package/dist/validation/OCREngine.d.ts

@@ -0,0 +1,75 @@
+/**
+ * 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 declare class OCREngine {
+    private tesseract;
+    private isInitialized;
+    constructor();
+    /**
+     * Initialize OCR engine
+     */
+    initialize(): Promise<void>;
+    /**
+     * Extract text from document image
+     */
+    extractText(imageData: string | Buffer): Promise<OCRResult[]>;
+    /**
+     * Extract structured data from ID document
+     */
+    extractDocumentData(frontImage: string | Buffer, backImage?: string | Buffer): Promise<DocumentData>;
+    /**
+     * Parse raw OCR text into structured document data
+     */
+    private parseDocumentData;
+    /**
+     * Extract field from text using regex
+     */
+    private extractField;
+    /**
+     * Extract and format date from text
+     */
+    private extractDate;
+    /**
+     * Extract gender from text
+     */
+    private extractGender;
+    /**
+     * Generate mock document number
+     */
+    private generateMockDocNumber;
+    /**
+     * Generate mock expiration date (2-5 years from now)
+     */
+    private generateExpirationDate;
+    /**
+     * Mock OCR results
+     */
+    private mockOCRResults;
+    /**
+     * Validate extracted document number format
+     */
+    validateDocumentNumber(documentNumber: string, documentType: string): boolean;
+    /**
+     * Clean up resources
+     */
+    dispose(): Promise<void>;
+}
+/**
+ * Clean and normalize extracted text
+ */
+export declare function cleanText(text: string): string;
+/**
+ * Validate date format
+ */
+export declare function isValidDate(dateString: string): boolean;

package/dist/validation/OCREngine.js

@@ -0,0 +1,225 @@
+"use strict";
+/**
+ * OCR Engine for extracting data from ID documents
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OCREngine = void 0;
+exports.cleanText = cleanText;
+exports.isValidDate = isValidDate;
+class OCREngine {
+    constructor() {
+        this.isInitialized = false;
+    }
+    /**
+     * Initialize OCR engine
+     */
+    async initialize() {
+        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) {
+        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, backImage) {
+        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
+     */
+    parseDocumentData(frontText, backText) {
+        // 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
+     */
+    extractField(text, pattern) {
+        const match = text.match(pattern);
+        return match ? match[1].trim() : null;
+    }
+    /**
+     * Extract and format date from text
+     */
+    extractDate(text, pattern) {
+        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
+     */
+    extractGender(text) {
+        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
+     */
+    generateMockDocNumber() {
+        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)
+     */
+    generateExpirationDate() {
+        const date = new Date();
+        date.setFullYear(date.getFullYear() + 2 + Math.floor(Math.random() * 3));
+        return date.toISOString().split('T')[0];
+    }
+    /**
+     * Mock OCR results
+     */
+    mockOCRResults() {
+        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, documentType) {
+        // 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() {
+        if (this.tesseract) {
+            // await this.tesseract.terminate();
+            this.tesseract = null;
+        }
+        this.isInitialized = false;
+    }
+}
+exports.OCREngine = OCREngine;
+/**
+ * Clean and normalize extracted text
+ */
+function cleanText(text) {
+    return text
+        .replace(/[^\w\s\-\/\.\:]/g, '') // Remove special characters
+        .replace(/\s+/g, ' ') // Normalize whitespace
+        .trim();
+}
+/**
+ * Validate date format
+ */
+function isValidDate(dateString) {
+    const date = new Date(dateString);
+    return date instanceof Date && !isNaN(date.getTime());
+}

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@hexar/biometric-identity-sdk-core",
+  "version": "1.0.0",
+  "description": "Core AI engine for biometric identity verification",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "private": false,
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "clean": "rm -rf dist"
+  },
+  "dependencies": {
+    "onnxruntime-node": "^1.17.0",
+    "onnxruntime-web": "^1.17.0",
+    "react-native-quick-crypto": "^1.0.3",
+    "sharp": "^0.33.2",
+    "tesseract.js": "^5.0.4"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.19",
+    "typescript": "^5.3.3"
+  }
+}