@hexar/biometric-identity-sdk-core 1.0.14 → 1.0.16

package/dist/BiometricIdentitySDK.d.ts

@@ -79,6 +79,24 @@ export declare class BiometricIdentitySDK {
      * Convert Blob to base64
      */
     private blobToBase64;
+    /**
+     * Compress base64 image - simplified version that works in all environments
+     * For React Native, images should be compressed at capture time
+     * This is a no-op for now - compression should happen at capture time in React Native
+     */
+    private compressImage;
+    /**
+     * Compress image in browser environment using Canvas API
+     */
+    private compressImageBrowser;
+    /**
+     * Fix base64 padding issues
+     */
+    private fixBase64Padding;
+    /**
+     * Validate if string is valid base64
+     */
+    private isValidBase64;
     /**
      * Get current SDK state
      */

package/dist/BiometricIdentitySDK.js

@@ -299,7 +299,7 @@ class BiometricIdentitySDK {
                     minimumRequired: 10
                 });
             }
-            const MAX_FRAMES = 30;
+            const MAX_FRAMES = 20;
             if (videoFrames.length > MAX_FRAMES) {
                 const step = Math.floor(videoFrames.length / MAX_FRAMES);
                 videoFrames = videoFrames.filter((_, index) => index % step === 0).slice(0, MAX_FRAMES);
@@ -308,17 +308,46 @@ class BiometricIdentitySDK {
                     sampledCount: videoFrames.length
                 });
             }
+            const compressedFrontImage = this.fixBase64Padding(await this.compressImage(this.state.frontID.data));
+            const compressedBackImage = this.state.backID?.data
+                ? this.fixBase64Padding(await this.compressImage(this.state.backID.data))
+                : undefined;
+            const validFrames = [];
+            for (let i = 0; i < videoFrames.length; i++) {
+                const frame = videoFrames[i];
+                if (!frame || typeof frame !== 'string') {
+                    logger_1.logger.warn(`Skipping invalid frame ${i}: not a string`);
+                    continue;
+                }
+                if (frame.length < 100) {
+                    logger_1.logger.warn(`Skipping invalid frame ${i}: too short (${frame.length} chars), likely a file path`);
+                    continue;
+                }
+                if (!this.isValidBase64(frame)) {
+                    logger_1.logger.warn(`Skipping invalid frame ${i}: not valid base64`);
+                    continue;
+                }
+                const compressedFrame = this.fixBase64Padding(await this.compressImage(frame));
+                validFrames.push(compressedFrame);
+            }
+            if (validFrames.length < 10) {
+                logger_1.logger.error(`Insufficient valid frames: ${validFrames.length} < 10`);
+                throw new Error(`Insufficient valid video frames: ${validFrames.length} frames available, minimum 10 required`);
+            }
             logger_1.logger.info('Sending validation request to backend', {
-                framesCount: videoFrames.length,
+                framesCount: validFrames.length,
                 duration: this.state.videoData.duration,
                 challengesCount: this.state.videoData.challengesCompleted?.length || 0,
-                frontImageSize: this.state.frontID.data?.length || 0,
-                backImageSize: this.state.backID?.data?.length || 0
+                frontImageSize: compressedFrontImage.length,
+                backImageSize: compressedBackImage?.length || 0,
+                originalFrontSize: this.state.frontID.data?.length || 0,
+                originalBackSize: this.state.backID?.data?.length || 0,
+                compressionRatio: compressedFrontImage.length / (this.state.frontID.data?.length || 1)
             });
             const response = await this.backendClient.fullValidation({
-                frontIdImage: this.state.frontID.data,
-                backIdImage: this.state.backID?.data,
-                videoFrames: videoFrames,
+                frontIdImage: compressedFrontImage,
+                backIdImage: compressedBackImage,
+                videoFrames: validFrames,
                 videoDurationMs: this.state.videoData.duration,
                 challengesCompleted: this.state.videoData.challengesCompleted || [],
             });
@@ -387,6 +416,92 @@ class BiometricIdentitySDK {
             reader.readAsDataURL(blob);
         });
     }
+    /**
+     * Compress base64 image - simplified version that works in all environments
+     * For React Native, images should be compressed at capture time
+     * This is a no-op for now - compression should happen at capture time in React Native
+     */
+    async compressImage(base64Image) {
+        if (!base64Image || base64Image.length === 0) {
+            return base64Image;
+        }
+        const MAX_SIZE = 1024 * 1024;
+        if (base64Image.length < MAX_SIZE) {
+            return base64Image;
+        }
+        try {
+            const globalWindow = globalThis.window;
+            if (globalWindow && globalWindow.Image && globalWindow.document) {
+                return await this.compressImageBrowser(base64Image, globalWindow);
+            }
+        }
+        catch (error) {
+            logger_1.logger.warn('Image compression not available, using original', error);
+        }
+        return base64Image;
+    }
+    /**
+     * Compress image in browser environment using Canvas API
+     */
+    async compressImageBrowser(base64Image, window) {
+        return new Promise((resolve, reject) => {
+            const img = new window.Image();
+            img.onload = () => {
+                const canvas = window.document.createElement('canvas');
+                const maxWidth = 1920;
+                const maxHeight = 1920;
+                let width = img.width;
+                let height = img.height;
+                if (width > maxWidth || height > maxHeight) {
+                    const ratio = Math.min(maxWidth / width, maxHeight / height);
+                    width = width * ratio;
+                    height = height * ratio;
+                }
+                canvas.width = width;
+                canvas.height = height;
+                const ctx = canvas.getContext('2d');
+                if (!ctx) {
+                    reject(new Error('Could not get canvas context'));
+                    return;
+                }
+                ctx.drawImage(img, 0, 0, width, height);
+                const compressedBase64 = canvas.toDataURL('image/jpeg', 0.85);
+                const base64 = compressedBase64.split(',')[1];
+                resolve(base64);
+            };
+            img.onerror = reject;
+            img.src = `data:image/jpeg;base64,${base64Image}`;
+        });
+    }
+    /**
+     * Fix base64 padding issues
+     */
+    fixBase64Padding(base64) {
+        if (!base64)
+            return base64;
+        let cleaned = base64.replace(/\s/g, '');
+        if (cleaned.includes(',')) {
+            cleaned = cleaned.split(',')[1] || cleaned;
+        }
+        const padding = cleaned.length % 4;
+        if (padding > 0) {
+            cleaned += '='.repeat(4 - padding);
+        }
+        return cleaned;
+    }
+    /**
+     * Validate if string is valid base64
+     */
+    isValidBase64(str) {
+        if (!str || typeof str !== 'string')
+            return false;
+        const cleaned = str.replace(/\s/g, '');
+        if (cleaned.includes(',')) {
+            return true;
+        }
+        const base64Regex = /^[A-Za-z0-9+/]*={0,2}$/;
+        return base64Regex.test(cleaned) && cleaned.length > 100;
+    }
     /**
      * Get current SDK state
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hexar/biometric-identity-sdk-core",
-  "version": "1.0.14",
+  "version": "1.0.16",
   "description": "Core AI engine for biometric identity verification",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/BiometricIdentitySDK.ts

@@ -381,7 +381,7 @@ export class BiometricIdentitySDK {
         });
       }
       
-      const MAX_FRAMES = 30;
+      const MAX_FRAMES = 20;
       if (videoFrames.length > MAX_FRAMES) {
         const step = Math.floor(videoFrames.length / MAX_FRAMES);
         videoFrames = videoFrames.filter((_, index) => index % step === 0).slice(0, MAX_FRAMES);
@@ -391,18 +391,53 @@ export class BiometricIdentitySDK {
         });
       }
       
+      const compressedFrontImage = this.fixBase64Padding(await this.compressImage(this.state.frontID.data));
+      const compressedBackImage = this.state.backID?.data 
+        ? this.fixBase64Padding(await this.compressImage(this.state.backID.data))
+        : undefined;
+      
+      const validFrames: string[] = [];
+      for (let i = 0; i < videoFrames.length; i++) {
+        const frame = videoFrames[i];
+        if (!frame || typeof frame !== 'string') {
+          logger.warn(`Skipping invalid frame ${i}: not a string`);
+          continue;
+        }
+        
+        if (frame.length < 100) {
+          logger.warn(`Skipping invalid frame ${i}: too short (${frame.length} chars), likely a file path`);
+          continue;
+        }
+        
+        if (!this.isValidBase64(frame)) {
+          logger.warn(`Skipping invalid frame ${i}: not valid base64`);
+          continue;
+        }
+        
+        const compressedFrame = this.fixBase64Padding(await this.compressImage(frame));
+        validFrames.push(compressedFrame);
+      }
+
+      if (validFrames.length < 10) {
+        logger.error(`Insufficient valid frames: ${validFrames.length} < 10`);
+        throw new Error(`Insufficient valid video frames: ${validFrames.length} frames available, minimum 10 required`);
+      }
+
       logger.info('Sending validation request to backend', {
-        framesCount: videoFrames.length,
+        framesCount: validFrames.length,
         duration: this.state.videoData.duration,
         challengesCount: this.state.videoData.challengesCompleted?.length || 0,
-        frontImageSize: this.state.frontID.data?.length || 0,
-        backImageSize: this.state.backID?.data?.length || 0
+        frontImageSize: compressedFrontImage.length,
+        backImageSize: compressedBackImage?.length || 0,
+        originalFrontSize: this.state.frontID.data?.length || 0,
+        originalBackSize: this.state.backID?.data?.length || 0,
+        compressionRatio: compressedFrontImage.length / (this.state.frontID.data?.length || 1)
       });
 
       const response = await this.backendClient.fullValidation({
-        frontIdImage: this.state.frontID.data,
-        backIdImage: this.state.backID?.data,
-        videoFrames: videoFrames,
+        frontIdImage: compressedFrontImage,
+        backIdImage: compressedBackImage,
+        videoFrames: validFrames,
         videoDurationMs: this.state.videoData.duration,
         challengesCompleted: this.state.videoData.challengesCompleted || [],
       });
@@ -486,6 +521,107 @@ export class BiometricIdentitySDK {
     });
   }
 
+  /**
+   * Compress base64 image - simplified version that works in all environments
+   * For React Native, images should be compressed at capture time
+   * This is a no-op for now - compression should happen at capture time in React Native
+   */
+  private async compressImage(base64Image: string): Promise<string> {
+    if (!base64Image || base64Image.length === 0) {
+      return base64Image;
+    }
+
+    const MAX_SIZE = 1024 * 1024;
+    if (base64Image.length < MAX_SIZE) {
+      return base64Image;
+    }
+
+    try {
+      const globalWindow = (globalThis as any).window;
+      if (globalWindow && globalWindow.Image && globalWindow.document) {
+        return await this.compressImageBrowser(base64Image, globalWindow);
+      }
+    } catch (error) {
+      logger.warn('Image compression not available, using original', error);
+    }
+
+    return base64Image;
+  }
+
+  /**
+   * Compress image in browser environment using Canvas API
+   */
+  private async compressImageBrowser(base64Image: string, window: any): Promise<string> {
+    return new Promise((resolve, reject) => {
+      const img = new window.Image();
+      img.onload = () => {
+        const canvas = window.document.createElement('canvas');
+        const maxWidth = 1920;
+        const maxHeight = 1920;
+        let width = img.width;
+        let height = img.height;
+
+        if (width > maxWidth || height > maxHeight) {
+          const ratio = Math.min(maxWidth / width, maxHeight / height);
+          width = width * ratio;
+          height = height * ratio;
+        }
+
+        canvas.width = width;
+        canvas.height = height;
+
+        const ctx = canvas.getContext('2d');
+        if (!ctx) {
+          reject(new Error('Could not get canvas context'));
+          return;
+        }
+
+        ctx.drawImage(img, 0, 0, width, height);
+        
+        const compressedBase64 = canvas.toDataURL('image/jpeg', 0.85);
+        const base64 = compressedBase64.split(',')[1];
+        resolve(base64);
+      };
+      img.onerror = reject;
+      img.src = `data:image/jpeg;base64,${base64Image}`;
+    });
+  }
+
+  /**
+   * Fix base64 padding issues
+   */
+  private fixBase64Padding(base64: string): string {
+    if (!base64) return base64;
+    
+    let cleaned = base64.replace(/\s/g, '');
+    
+    if (cleaned.includes(',')) {
+      cleaned = cleaned.split(',')[1] || cleaned;
+    }
+    
+    const padding = cleaned.length % 4;
+    if (padding > 0) {
+      cleaned += '='.repeat(4 - padding);
+    }
+    
+    return cleaned;
+  }
+
+  /**
+   * Validate if string is valid base64
+   */
+  private isValidBase64(str: string): boolean {
+    if (!str || typeof str !== 'string') return false;
+    
+    const cleaned = str.replace(/\s/g, '');
+    if (cleaned.includes(',')) {
+      return true;
+    }
+    
+    const base64Regex = /^[A-Za-z0-9+/]*={0,2}$/;
+    return base64Regex.test(cleaned) && cleaned.length > 100;
+  }
+
   /**
    * Get current SDK state
    */