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

package/dist/BiometricIdentitySDK.d.ts

@@ -79,6 +79,16 @@ 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;
     /**
      * 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,25 @@ class BiometricIdentitySDK {
                     sampledCount: videoFrames.length
                 });
             }
+            const compressedFrontImage = await this.compressImage(this.state.frontID.data);
+            const compressedBackImage = this.state.backID?.data
+                ? await this.compressImage(this.state.backID.data)
+                : undefined;
+            const compressedFrames = await Promise.all(videoFrames.map(frame => this.compressImage(frame)));
             logger_1.logger.info('Sending validation request to backend', {
-                framesCount: videoFrames.length,
+                framesCount: compressedFrames.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: compressedFrames,
                 videoDurationMs: this.state.videoData.duration,
                 challengesCompleted: this.state.videoData.challengesCompleted || [],
             });
@@ -387,6 +395,63 @@ 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}`;
+        });
+    }
     /**
      * Get current SDK state
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hexar/biometric-identity-sdk-core",
-  "version": "1.0.14",
+  "version": "1.0.15",
   "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,29 @@ export class BiometricIdentitySDK {
         });
       }
       
+      const compressedFrontImage = await this.compressImage(this.state.frontID.data);
+      const compressedBackImage = this.state.backID?.data 
+        ? await this.compressImage(this.state.backID.data)
+        : undefined;
+      const compressedFrames = await Promise.all(
+        videoFrames.map(frame => this.compressImage(frame))
+      );
+
       logger.info('Sending validation request to backend', {
-        framesCount: videoFrames.length,
+        framesCount: compressedFrames.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: compressedFrames,
         videoDurationMs: this.state.videoData.duration,
         challengesCompleted: this.state.videoData.challengesCompleted || [],
       });
@@ -486,6 +497,72 @@ 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}`;
+    });
+  }
+
   /**
    * Get current SDK state
    */