scandoc-ai-components 0.1.16 → 0.1.18

package/dist/index.js

@@ -11170,18 +11170,21 @@ __webpack_require__.r(__webpack_exports__);
 
 const DOCUMENT_DETECTOR = new _ai_detect_document__WEBPACK_IMPORTED_MODULE_0__["default"]();
 class ExtractorVideo {
+  static DEBUG = true;
   static FREQUENCY_MS = 10;
   static VALIDATION_BATCH_SIZE = 1;
   static VALIDATION_IMG_WIDTH = 384;
   static VALIDATION_IMG_HEIGHT = 384;
-  static VIDEO_SETTINGS = Object.freeze({
-    width: {
-      ideal: 1920
-    },
-    height: {
-      ideal: 1080
-    }
-  });
+  static VIDEO_CANDIDATE_SETTINGS = Object.freeze([{
+    width: 1920,
+    height: 1080
+  }, {
+    width: 1280,
+    height: 960
+  }, {
+    width: 1280,
+    height: 720
+  }]);
   constructor(onExtractedResults) {
     this.candidateImages = [];
     this.extractionImages = {};
@@ -11195,10 +11198,48 @@ class ExtractorVideo {
     this.waitingForSecondSide = false;
     this.hasShownTurnMessage = false;
     this.turnMessageTimer = null;
-
-    // initialize through setter so we see the first set too:
+    this.debugLog = [];
     this.onExtractedResults = onExtractedResults;
   }
+  logDebug(event, data = {}) {
+    if (!ExtractorVideo.DEBUG) return;
+    const entry = {
+      ts: new Date().toISOString(),
+      event,
+      data
+    };
+    this.debugLog.push(entry);
+    try {
+      console.log("[ScanDocAI]", event, data);
+    } catch (_) {}
+  }
+  getDebugDump() {
+    return {
+      userAgent: navigator.userAgent,
+      secureContext: window.isSecureContext,
+      location: window.location.href,
+      videoPresent: !!this.video,
+      videoReadyState: this.video?.readyState,
+      videoNetworkState: this.video?.networkState,
+      videoPaused: this.video?.paused,
+      videoMuted: this.video?.muted,
+      videoAutoplay: this.video?.autoplay,
+      videoPlaysInline: this.video?.playsInline,
+      videoDimensions: {
+        videoWidth: this.video?.videoWidth || 0,
+        videoHeight: this.video?.videoHeight || 0,
+        clientWidth: this.video?.clientWidth || 0,
+        clientHeight: this.video?.clientHeight || 0
+      },
+      streamTracks: this.video?.srcObject ? this.video.srcObject.getTracks().map(t => ({
+        kind: t.kind,
+        label: t.label,
+        readyState: t.readyState,
+        enabled: t.enabled
+      })) : [],
+      log: this.debugLog
+    };
+  }
   reset() {
     this.stopVideo();
     this.candidateImages = [];
@@ -11215,12 +11256,16 @@ class ExtractorVideo {
     this.hasShownTurnMessage = false;
     clearTimeout(this.turnMessageTimer);
     this.turnMessageTimer = null;
+    this.debugLog = [];
   }
   async analyzeVideoStream() {
     if (!this.isRunning) return;
     const now = Date.now();
     const cfgValues = (0,_config__WEBPACK_IMPORTED_MODULE_1__.getScanDocAIConfigValues)();
     if (this.scanStartTime && now - this.scanStartTime > cfgValues.MAX_SCAN_DURATION_MS) {
+      this.logDebug("scan_timeout", {
+        elapsedMs: now - this.scanStartTime
+      });
       this.stopVideo();
       this.onExtractedResults({
         success: false,
@@ -11231,7 +11276,16 @@ class ExtractorVideo {
     }
     const canvas = document.createElement("canvas");
     const video = document.getElementById("ScanDocAIVideoElement");
-    if (video && video.videoWidth < video.videoHeight) {
+    if (!video) {
+      this.logDebug("analyze_no_video_element");
+      setTimeout(() => this.analyzeVideoStream(), ExtractorVideo.FREQUENCY_MS);
+      return;
+    }
+    if (video.videoWidth < video.videoHeight) {
+      this.logDebug("portrait_video_detected", {
+        videoWidth: video.videoWidth,
+        videoHeight: video.videoHeight
+      });
       this.showMessage("Please rotate your device to landscape mode.");
       this.candidateImages = [];
       setTimeout(() => this.analyzeVideoStream(), ExtractorVideo.FREQUENCY_MS);
@@ -11250,6 +11304,9 @@ class ExtractorVideo {
       const [isValidationOk, response] = await (0,_requests_validation__WEBPACK_IMPORTED_MODULE_3__["default"])(images.map(e => e.validationImg), this.pastBlurValues, {});
       if (!isValidationOk) {
         const msg = Array.isArray(response) ? response.join(", ") : String(response || "");
+        this.logDebug("validation_failed", {
+          response: msg
+        });
         if (msg.toLowerCase().includes("token expired/invalid")) {
           this.stopVideo();
           this.showMessage("Token expired/invalid. Please provide a new token.", true);
@@ -11264,6 +11321,7 @@ class ExtractorVideo {
         return;
       }
       if (response?.InfoCode === "1006" && response?.TransactionID) {
+        this.logDebug("unsupported_document", response);
         const frontImage = this.candidateImages[this.candidateImages.length - 1].fullImg;
         await (0,_requests_error_logging__WEBPACK_IMPORTED_MODULE_4__["default"])(frontImage, "", response.TransactionID, response.OS, response.Device, response.Browser);
         this.showMessage("Document not supported.", true);
@@ -11294,13 +11352,11 @@ class ExtractorVideo {
           this.hasShownTurnMessage = true;
           this.scanStartTime = Date.now();
           this.showMessage("Turn to the other side", true);
-
-          // Clear lock after 3 seconds
           clearTimeout(this.turnMessageTimer);
           this.turnMessageTimer = setTimeout(() => {
             this.hasShownTurnMessage = false;
             this.waitingForSecondSide = false;
-            this.lastMessage = null; // allow same message again later
+            this.lastMessage = null;
           }, 3000);
         } else if (Object.keys(this.extractionImages).length === 2) {
           this.waitingForSecondSide = false;
@@ -11347,6 +11403,10 @@ class ExtractorVideo {
         return;
       }
       this.candidateImages = [];
+    }).catch(err => {
+      this.logDebug("document_detector_error", {
+        message: err?.message || String(err)
+      });
     }).finally(() => {
       setTimeout(() => this.analyzeVideoStream(), ExtractorVideo.FREQUENCY_MS);
     });
@@ -11367,7 +11427,7 @@ class ExtractorVideo {
     this.turnMessageTimer = null;
     this.stopVideo();
     if (isExtractionOk) {
-      this.showMessage("Success - data extracted", true);
+      this.showMessage("Success - data extracted", "success");
       const shouldStop = this.onExtractedResults({
         success: true,
         code: "001",
@@ -11375,7 +11435,7 @@ class ExtractorVideo {
         data: extractionData
       });
       if (shouldStop === true) {
-        setTimeout(() => this.startVideo(), ExtractorVideo.FREQUENCY_MS);
+        setTimeout(() => this.analyzeVideoStream(), ExtractorVideo.FREQUENCY_MS);
       }
     } else {
       this.onExtractedResults({
@@ -11383,11 +11443,428 @@ class ExtractorVideo {
         code: "005",
         info: "Document validation passed but extraction failed."
       });
-      setTimeout(() => this.startVideo(), ExtractorVideo.FREQUENCY_MS);
+      setTimeout(() => this.analyzeVideoStream(), ExtractorVideo.FREQUENCY_MS);
+    }
+  }
+  getSupportedConstraintsSafe() {
+    if (!navigator.mediaDevices?.getSupportedConstraints) return {};
+    try {
+      return navigator.mediaDevices.getSupportedConstraints();
+    } catch (_) {
+      return {};
+    }
+  }
+  getAspectRatio(settings) {
+    if (typeof settings?.aspectRatio === "number" && settings.aspectRatio > 0) {
+      return settings.aspectRatio;
+    }
+    if (settings?.width && settings?.height) {
+      return settings.width / settings.height;
+    }
+    return null;
+  }
+  isLandscape(settings) {
+    return (settings?.width || 0) > (settings?.height || 0);
+  }
+  isFrontLabel(label) {
+    const l = (label || "").toLowerCase();
+    return l.includes("front") || l.includes("selfie") || l.includes("user facing") || l.includes("facing front");
+  }
+  isRearLikeLabel(label) {
+    const l = (label || "").toLowerCase();
+    return l.includes("rear") || l.includes("back") || l.includes("environment") || l.includes("facing back") || l.includes("facing rear");
+  }
+  scoreTrack({
+    settings,
+    label
+  }) {
+    const width = settings?.width || 0;
+    const height = settings?.height || 0;
+    const pixels = width * height;
+    const aspectRatio = this.getAspectRatio(settings) || 0;
+    let score = pixels;
+    if (width > height) score += 1_000_000_000;
+    if (aspectRatio >= 1.3) score += 100_000_000;
+    if (this.isRearLikeLabel(label)) score += 10_000_000;
+    if (this.isFrontLabel(label)) score -= 10_000_000_000;
+    return score;
+  }
+  buildVideoConstraints({
+    width,
+    height,
+    mode,
+    deviceId
+  }) {
+    const supported = this.getSupportedConstraintsSafe();
+    const video = {};
+    if (deviceId) {
+      video.deviceId = {
+        exact: deviceId
+      };
+    } else if (supported.facingMode) {
+      if (typeof mode === "string") {
+        video.facingMode = {
+          ideal: mode
+        };
+      } else if (mode && typeof mode === "object") {
+        video.facingMode = mode;
+      } else {
+        video.facingMode = {
+          ideal: "environment"
+        };
+      }
+    }
+    if (supported.width) video.width = {
+      ideal: width
+    };
+    if (supported.height) video.height = {
+      ideal: height
+    };
+    if (supported.aspectRatio) video.aspectRatio = {
+      ideal: width / height
+    };
+    return {
+      video,
+      audio: false
+    };
+  }
+  async pauseBetweenCameraOps(ms = 180) {
+    await new Promise(resolve => setTimeout(resolve, ms));
+  }
+  async stopMediaStream(stream) {
+    if (!stream) return;
+    try {
+      stream.getTracks().forEach(t => t.stop());
+    } catch (_) {}
+    await this.pauseBetweenCameraOps();
+  }
+  async tryEnableDocumentFocus(stream) {
+    const track = stream?.getVideoTracks?.()[0];
+    if (!track) {
+      this.logDebug("focus_no_track");
+      return {
+        ok: false,
+        reason: "No video track found"
+      };
+    }
+    if (!track.getCapabilities || !track.applyConstraints) {
+      this.logDebug("focus_api_unavailable");
+      return {
+        ok: false,
+        reason: "Focus APIs unavailable on this browser/device",
+        settingsBefore: track.getSettings ? track.getSettings() : null
+      };
+    }
+    const caps = track.getCapabilities();
+    const result = {
+      ok: true,
+      capabilities: caps,
+      attempts: [],
+      settingsBefore: track.getSettings ? track.getSettings() : null
+    };
+    try {
+      let applied = false;
+      if (Array.isArray(caps.focusMode) && caps.focusMode.includes("continuous")) {
+        await track.applyConstraints({
+          advanced: [{
+            focusMode: "continuous"
+          }]
+        });
+        result.attempts.push("Applied focusMode=continuous");
+        applied = true;
+      }
+      if (caps.focusDistance) {
+        const min = caps.focusDistance.min;
+        const max = caps.focusDistance.max;
+        const docDistance = min + (max - min) * 0.30;
+        const advanced = [];
+        if (Array.isArray(caps.focusMode) && caps.focusMode.includes("manual")) {
+          advanced.push({
+            focusMode: "manual"
+          });
+        }
+        advanced.push({
+          focusDistance: docDistance
+        });
+        await track.applyConstraints({
+          advanced
+        });
+        result.attempts.push(`Applied focusDistance=${docDistance}`);
+        applied = true;
+      }
+      if (!applied) {
+        result.ok = false;
+        result.reason = "No supported focus controls were exposed";
+      }
+      result.settingsAfter = track.getSettings ? track.getSettings() : null;
+      this.logDebug("focus_result", result);
+      return result;
+    } catch (err) {
+      result.ok = false;
+      result.error = err.message || String(err);
+      result.settingsAfter = track.getSettings ? track.getSettings() : null;
+      this.logDebug("focus_error", result);
+      return result;
+    }
+  }
+  async openCandidateStream({
+    mode,
+    deviceId,
+    width,
+    height
+  }) {
+    const constraints = this.buildVideoConstraints({
+      width,
+      height,
+      mode,
+      deviceId
+    });
+    this.logDebug("getUserMedia_attempt", {
+      constraints
+    });
+    const stream = await navigator.mediaDevices.getUserMedia(constraints);
+    this.logDebug("getUserMedia_success", {
+      deviceId,
+      width,
+      height,
+      trackLabels: stream.getTracks().map(t => t.label)
+    });
+    return stream;
+  }
+  async testDeviceAtPreferredResolutions(device, mode) {
+    const attempts = [];
+    for (const size of ExtractorVideo.VIDEO_CANDIDATE_SETTINGS) {
+      let stream = null;
+      try {
+        stream = await this.openCandidateStream({
+          mode,
+          deviceId: device?.deviceId,
+          width: size.width,
+          height: size.height
+        });
+        const track = stream.getVideoTracks()[0];
+        const settings = track.getSettings();
+        const label = track.label || device?.label || "";
+        const aspectRatio = this.getAspectRatio(settings);
+        const result = {
+          stream,
+          label,
+          settings,
+          aspectRatio,
+          landscape: this.isLandscape(settings),
+          score: this.scoreTrack({
+            settings,
+            label
+          }),
+          requested: size
+        };
+        attempts.push({
+          ok: true,
+          requested: size,
+          returnedWidth: settings.width,
+          returnedHeight: settings.height,
+          aspectRatio,
+          label
+        });
+        this.logDebug("device_test_success", {
+          deviceLabel: device?.label,
+          deviceId: device?.deviceId,
+          requested: size,
+          settings,
+          label
+        });
+        return {
+          result,
+          attempts
+        };
+      } catch (err) {
+        attempts.push({
+          ok: false,
+          requested: size,
+          error: err.message || String(err)
+        });
+        this.logDebug("device_test_error", {
+          deviceLabel: device?.label,
+          deviceId: device?.deviceId,
+          requested: size,
+          error: err?.message || String(err),
+          name: err?.name
+        });
+        await this.stopMediaStream(stream);
+      }
+    }
+    return {
+      result: null,
+      attempts
+    };
+  }
+  async pickBestPhoneCamera(mode = "environment") {
+    const debug = {
+      mode,
+      tested: []
+    };
+    let warmupStream = null;
+    let warmupResult = null;
+    try {
+      const warmupSize = ExtractorVideo.VIDEO_CANDIDATE_SETTINGS[2];
+      warmupStream = await this.openCandidateStream({
+        mode,
+        width: warmupSize.width,
+        height: warmupSize.height
+      });
+      const track = warmupStream.getVideoTracks()[0];
+      const settings = track.getSettings();
+      const label = track.label || "";
+      warmupResult = {
+        stream: warmupStream,
+        label,
+        settings,
+        aspectRatio: this.getAspectRatio(settings),
+        landscape: this.isLandscape(settings),
+        score: this.scoreTrack({
+          settings,
+          label
+        }),
+        requested: warmupSize
+      };
+      this.logDebug("warmup_success", {
+        label,
+        settings
+      });
+    } catch (err) {
+      this.logDebug("warmup_error", {
+        name: err?.name,
+        message: err?.message || String(err)
+      });
+      warmupStream = null;
+    }
+    let devices = [];
+    try {
+      devices = await navigator.mediaDevices.enumerateDevices();
+      this.logDebug("enumerate_devices", {
+        devices: devices.map(d => ({
+          kind: d.kind,
+          label: d.label,
+          deviceId: d.deviceId
+        }))
+      });
+    } catch (err) {
+      this.logDebug("enumerate_devices_error", {
+        name: err?.name,
+        message: err?.message || String(err)
+      });
+      devices = [];
+    }
+    const videoInputs = devices.filter(d => d.kind === "videoinput");
+    const candidateDevices = mode === "environment" ? videoInputs.filter(d => !this.isFrontLabel(d.label)) : videoInputs;
+    if (warmupStream) {
+      await this.stopMediaStream(warmupStream);
+      warmupStream = null;
+    }
+    const usableResults = [];
+    for (let i = 0; i < candidateDevices.length; i += 1) {
+      const device = candidateDevices[i];
+      const {
+        result,
+        attempts
+      } = await this.testDeviceAtPreferredResolutions(device, mode);
+      debug.tested.push({
+        deviceId: device.deviceId,
+        label: device.label,
+        attempts,
+        final: result ? {
+          label: result.label,
+          settings: result.settings,
+          aspectRatio: result.aspectRatio,
+          landscape: result.landscape,
+          score: result.score,
+          requested: result.requested
+        } : null
+      });
+      if (result) {
+        const frontRejected = mode === "environment" && this.isFrontLabel(result.label);
+        const geometryOk = result.landscape;
+        if (!frontRejected && geometryOk) {
+          usableResults.push(result);
+        } else {
+          await this.stopMediaStream(result.stream);
+        }
+      }
+    }
+    if (usableResults.length > 0) {
+      usableResults.sort((a, b) => b.score - a.score);
+      const chosen = usableResults[0];
+      for (const candidate of usableResults) {
+        if (candidate !== chosen) {
+          await this.stopMediaStream(candidate.stream);
+        }
+      }
+      debug.chosen = {
+        label: chosen.label,
+        settings: chosen.settings,
+        aspectRatio: chosen.aspectRatio,
+        requested: chosen.requested,
+        source: "device-test"
+      };
+      this.logDebug("camera_chosen", debug.chosen);
+      return {
+        chosen,
+        debug
+      };
+    }
+    for (const size of ExtractorVideo.VIDEO_CANDIDATE_SETTINGS) {
+      try {
+        const stream = await this.openCandidateStream({
+          mode,
+          width: size.width,
+          height: size.height
+        });
+        const track = stream.getVideoTracks()[0];
+        const settings = track.getSettings();
+        const label = track.label || "";
+        const aspectRatio = this.getAspectRatio(settings);
+        const landscape = this.isLandscape(settings);
+        if (mode === "environment" && !landscape) {
+          await this.stopMediaStream(stream);
+          continue;
+        }
+        const chosen = {
+          stream,
+          label,
+          settings,
+          aspectRatio,
+          landscape,
+          score: this.scoreTrack({
+            settings,
+            label
+          }),
+          requested: size
+        };
+        debug.chosen = {
+          label,
+          settings,
+          aspectRatio,
+          requested: size,
+          source: "fallback-facingMode"
+        };
+        this.logDebug("camera_chosen_fallback", debug.chosen);
+        return {
+          chosen,
+          debug
+        };
+      } catch (err) {
+        this.logDebug("fallback_open_error", {
+          requested: size,
+          name: err?.name,
+          message: err?.message || String(err)
+        });
+      }
     }
+    throw new Error("Could not start a suitable camera.");
   }
   async startVideo() {
     try {
+      this.logDebug("startVideo_begin");
       const serviceConfig = (0,_config__WEBPACK_IMPORTED_MODULE_1__.getScanDocAIConfig)();
       await serviceConfig.getAccessToken(false);
       const videoElem = document.getElementById("ScanDocAIVideoElement");
@@ -11399,63 +11876,80 @@ class ExtractorVideo {
       this.scanStartTime = Date.now();
       const cfgValues = (0,_config__WEBPACK_IMPORTED_MODULE_1__.getScanDocAIConfigValues)();
       const mode = cfgValues.VIDEO_FACING_MODE ?? "environment";
-      let stream;
-      try {
-        stream = await navigator.mediaDevices.getUserMedia(buildDocumentScanConstraints(mode));
-      } catch (e) {
-        console.warn("Preferred camera constraints failed, falling back:", e);
-        stream = await navigator.mediaDevices.getUserMedia({
-          video: true,
-          audio: false
-        });
-      }
-      this.video.srcObject = stream;
+      const {
+        chosen,
+        debug
+      } = await this.pickBestPhoneCamera(mode);
+      this.video.srcObject = chosen.stream;
+      this.logDebug("srcObject_assigned", {
+        label: chosen.label,
+        settings: chosen.settings
+      });
       try {
         await this.video.play();
+        this.logDebug("video_play_success", {
+          readyState: this.video.readyState,
+          videoWidth: this.video.videoWidth,
+          videoHeight: this.video.videoHeight
+        });
       } catch (e) {
-        console.warn(`Error on video play: ${e}`);
-      }
-
-      // Try to improve document focus after stream is active
-      try {
-        const focusResult = await tryEnableDocumentFocus(stream);
-        console.log("Focus result:", focusResult);
-      } catch (focusError) {
-        console.warn("Could not apply focus settings:", focusError);
-      }
-
-      // Avoid re-binding listeners every start
-      if (!this._boundLoadedDataHandler) {
-        this._boundLoadedDataHandler = () => this.adjustOverlayPosition();
-        this.video.addEventListener("loadeddata", this._boundLoadedDataHandler);
-      }
-      if (!this._boundResizeHandler) {
-        this._boundResizeHandler = () => this.adjustOverlayPosition();
-        window.addEventListener("resize", this._boundResizeHandler);
+        this.logDebug("video_play_error", {
+          name: e?.name,
+          message: e?.message || String(e)
+        });
+        throw e;
       }
+      this.focusDebug = await this.tryEnableDocumentFocus(chosen.stream);
+      this.cameraDebug = debug;
+      this.video.addEventListener("loadeddata", () => {
+        this.logDebug("video_loadeddata", {
+          videoWidth: this.video.videoWidth,
+          videoHeight: this.video.videoHeight
+        });
+        this.adjustOverlayPosition();
+      });
+      this.video.addEventListener("error", () => {
+        this.logDebug("video_element_error", {
+          error: this.video?.error ? {
+            code: this.video.error.code,
+            message: this.video.error.message
+          } : null
+        });
+      });
+      window.addEventListener("resize", () => this.adjustOverlayPosition());
       setTimeout(() => this.adjustOverlayPosition(), 500);
       this.scanStartTime = Date.now();
       setTimeout(() => this.analyzeVideoStream(), ExtractorVideo.FREQUENCY_MS);
       this.showMessage("Starting scanning");
+      this.logDebug("startVideo_success", this.getDebugDump());
       return true;
     } catch (error) {
       console.error("startVideo failed:", error);
+      this.logDebug("startVideo_failed", {
+        name: error?.name,
+        message: error?.message || String(error),
+        dump: this.getDebugDump()
+      });
       this.isRunning = false;
       this.stopVideo();
       this.onExtractedResults({
         success: false,
         code: error.status === 401 || error.status === 403 ? "004" : "005",
-        info: error.status === 401 || error.status === 403 ? "Authentication failed: Invalid API key/token." : "Startup failed: " + (error.message || "Unknown error")
+        info: error.status === 401 || error.status === 403 ? "Authentication failed: Invalid API key/token." : "Startup failed: " + (error.message || "Unknown error"),
+        debug: ExtractorVideo.DEBUG ? this.getDebugDump() : undefined
       });
       return false;
     }
   }
   stopVideo() {
     this.isRunning = false;
+    this.logDebug("stopVideo_called");
     if (this.video) {
       this.video.pause();
       if (this.video.srcObject !== undefined && this.video.srcObject !== null) {
-        this.video.srcObject.getTracks().forEach(t => t.stop());
+        try {
+          this.video.srcObject.getTracks().forEach(t => t.stop());
+        } catch (_) {}
       }
       this.video.srcObject = null;
     }
@@ -11482,7 +11976,7 @@ class ExtractorVideo {
     const centerX = offsetX + scaleWidth / 2;
     const centerY = offsetY + scaleHeight / 2;
     dot.style.display = "block";
-    dot.style.left = `${centerX - 8}px`; // center minus half dot size
+    dot.style.left = `${centerX - 8}px`;
     dot.style.top = `${centerY - 8}px`;
   }
   getHTML() {
@@ -11491,7 +11985,6 @@ class ExtractorVideo {
     const messageColor = cfgValues.VIDEO_COLORS?.messageColor;
     const isMobile = window.innerWidth < 768 || window.innerHeight > window.innerWidth && window.innerWidth < 1024;
     if (isMobile) {
-      // Mobile version with overlay feedback
       return `
 				<div class="mobileVideoArea">
 					<video id="ScanDocAIVideoElement" class="mobileVideo" autoplay muted playsinline></video>
@@ -11577,13 +12070,11 @@ class ExtractorVideo {
 						margin-left: 20%;
 						margin-right: 20%;
 					}
-		
 					.desktopVideoHolder {
 						position: relative;
 						width: 100%;
 						overflow: hidden;
 					}
-
 					.desktopVideo {
 						width: 100%;
 						height: auto;
@@ -11592,7 +12083,6 @@ class ExtractorVideo {
 						max-width: 100vw;
 						max-height: 100vh;
 					}
-					
 					.centerGuideDot {
 						position: absolute;
 						width: 16px;
@@ -11603,14 +12093,12 @@ class ExtractorVideo {
 						z-index: 4;
 						animation: flicker 1s infinite;
 						pointer-events: none;
-						display: none; /* Hidden until video is ready */
+						display: none;
 					}
-
 					@keyframes flicker {
 						0%, 100% { opacity: 1; }
 						50% { opacity: 0.3; }
 					}
-
 					.backgroundOverlay {
 						position: absolute;
 						top: 0;
@@ -11621,7 +12109,6 @@ class ExtractorVideo {
 						z-index: 2;
 						pointer-events: none;
 					}
-		
 					.desktopFeedback {
 						position: relative;
 						display: flex;
@@ -11657,8 +12144,6 @@ function getExtractionVideo(tokenOrCallback, maybeCallback) {
     EXTRACTION_VIDEO = new ExtractorVideo(cb);
     return EXTRACTION_VIDEO;
   }
-
-  // If called again, update callback too
   if (typeof cb === "function") {
     EXTRACTION_VIDEO.onExtractedResults = cb;
   } else if (cb !== undefined) {
@@ -11666,143 +12151,6 @@ function getExtractionVideo(tokenOrCallback, maybeCallback) {
   }
   return EXTRACTION_VIDEO;
 }
-function getSupportedConstraintsSafe() {
-  try {
-    return navigator.mediaDevices?.getSupportedConstraints?.() || {};
-  } catch (_) {
-    return {};
-  }
-}
-function buildDocumentScanConstraints(mode = "environment") {
-  const supported = getSupportedConstraintsSafe();
-  const video = {};
-  if (supported.facingMode) {
-    video.facingMode = typeof mode === "string" ? {
-      ideal: mode
-    } : mode || {
-      ideal: "environment"
-    };
-  }
-  if (supported.width) {
-    video.width = {
-      ideal: 1920
-    };
-  }
-  if (supported.height) {
-    video.height = {
-      ideal: 1080
-    };
-  }
-  if (supported.aspectRatio) {
-    video.aspectRatio = {
-      ideal: 16 / 9
-    };
-  }
-  return {
-    video,
-    audio: false
-  };
-}
-async function tryEnableDocumentFocus(stream) {
-  const track = stream?.getVideoTracks?.()[0];
-  if (!track) {
-    return {
-      ok: false,
-      reason: "No video track found"
-    };
-  }
-  if (!track.getCapabilities || !track.applyConstraints) {
-    return {
-      ok: false,
-      reason: "Focus APIs unavailable on this browser/device",
-      settingsBefore: track.getSettings ? track.getSettings() : null
-    };
-  }
-  const caps = track.getCapabilities();
-  const result = {
-    ok: true,
-    capabilities: caps,
-    attempts: [],
-    settingsBefore: track.getSettings ? track.getSettings() : null
-  };
-  try {
-    let applied = false;
-    if (Array.isArray(caps.focusMode) && caps.focusMode.includes("continuous")) {
-      await track.applyConstraints({
-        advanced: [{
-          focusMode: "continuous"
-        }]
-      });
-      result.attempts.push("Applied focusMode=continuous");
-      applied = true;
-    }
-    if (caps.focusDistance) {
-      const min = caps.focusDistance.min ?? 0;
-      const max = caps.focusDistance.max ?? 0;
-      const docDistance = min + (max - min) * 0.3;
-      const advanced = [];
-      if (Array.isArray(caps.focusMode) && caps.focusMode.includes("manual")) {
-        advanced.push({
-          focusMode: "manual"
-        });
-      }
-      advanced.push({
-        focusDistance: docDistance
-      });
-      await track.applyConstraints({
-        advanced
-      });
-      result.attempts.push(`Applied focusDistance=${docDistance}`);
-      applied = true;
-    }
-    if (!applied) {
-      result.ok = false;
-      result.reason = "No supported focus controls were exposed";
-    }
-    result.settingsAfter = track.getSettings ? track.getSettings() : null;
-    return result;
-  } catch (err) {
-    result.ok = false;
-    result.error = err.message || String(err);
-    result.settingsAfter = track.getSettings ? track.getSettings() : null;
-    return result;
-  }
-}
-async function checkAutofocusSupport(environmentCameras) {
-  try {
-    const camerasWithAutofocus = [];
-    for (const camera of environmentCameras) {
-      // console.log(camera.deviceId);
-      const constraints = {
-        video: {
-          deviceId: {
-            exact: camera.deviceId
-          }
-        }
-      };
-
-      // Try to access camera stream with autofocus enabled
-      const stream = await navigator.mediaDevices.getUserMedia(constraints);
-      const tracks = stream.getVideoTracks();
-      const track = tracks[0];
-      if (track) {
-        // Check if autofocus is supported
-        const capabilities = track.getCapabilities();
-        // console.log(capabilities);
-        if (capabilities.focusMode && capabilities.focusMode.includes("continuous")) {
-          camerasWithAutofocus.push(camera);
-        }
-      }
-
-      // Cleanup
-      stream.getTracks().forEach(track => track.stop());
-    }
-    return camerasWithAutofocus;
-  } catch (error) {
-    console.log("Error checking autofocus support:", error);
-    return [];
-  }
-}
 
 /***/ }),
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "scandoc-ai-components",
   "author": "ScanDoc-AI",
-  "version": "0.1.16",
+  "version": "0.1.18",
   "private": false,
   "description": "Pure JavaScript package for integrating ScanDoc-AI services.",
   "keywords": [