@ayasofyazilim/ui 0.0.0 → 0.0.1

package/dist/custom/document-scanner/hooks/use-document-scanner.js

@@ -0,0 +1,59 @@
+import { useCallback, useState } from "react";
+import { DEFAULT_VIDEO_DIMENSIONS } from "../consts";
+function useDocumentScanner(callbacks) {
+  const [videoDimensions, setVideoDimensions] = useState(
+    DEFAULT_VIDEO_DIMENSIONS
+  );
+  const [detectedCorners, setDetectedCorners] = useState();
+  const [capturedImage, setCapturedImage] = useState(null);
+  const handleVideoReady = useCallback(
+    (dimensions) => {
+      setVideoDimensions(dimensions);
+      callbacks.onStatusChange?.("scanning");
+      callbacks.onCameraReady?.(dimensions);
+    },
+    [callbacks]
+  );
+  const handleCornersChange = useCallback(
+    (newCorners) => {
+      setDetectedCorners(newCorners);
+      callbacks.onCornersChanged?.(newCorners);
+    },
+    [callbacks]
+  );
+  const handleError = useCallback(
+    (error) => {
+      callbacks.onStatusChange?.("error");
+      callbacks.onError?.(error);
+    },
+    [callbacks]
+  );
+  const handleImageCrop = useCallback(
+    (croppedImageBase64) => {
+      callbacks.onStatusChange?.("cropped");
+      callbacks.onDocumentCropped?.(croppedImageBase64);
+    },
+    [callbacks]
+  );
+  const handleRetry = useCallback(() => {
+    setDetectedCorners(void 0);
+    setCapturedImage(null);
+    callbacks.onStatusChange?.("scanning");
+  }, [callbacks]);
+  return {
+    videoDimensions,
+    detectedCorners,
+    capturedImage,
+    handleVideoReady,
+    handleCornersChange,
+    handleError,
+    handleImageCrop,
+    handleRetry,
+    setCapturedImage,
+    setDetectedCorners
+  };
+}
+export {
+  useDocumentScanner
+};
+//# sourceMappingURL=use-document-scanner.js.map

package/dist/custom/document-scanner/hooks/use-document-scanner.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/custom/document-scanner/hooks/use-document-scanner.ts"],"sourcesContent":["import { useCallback, useState } from \"react\";\r\nimport { DocumentCorners, DocumentScannerCallbacks } from \"../types\";\r\nimport { DEFAULT_VIDEO_DIMENSIONS } from \"../consts\";\r\n\r\nexport interface UseDocumentScannerReturn {\r\n  videoDimensions: { width: number; height: number };\r\n  detectedCorners: DocumentCorners | undefined;\r\n  capturedImage: string | null;\r\n  handleVideoReady: (dimensions: { width: number; height: number }) => void;\r\n  handleCornersChange: (newCorners: DocumentCorners) => void;\r\n  handleError: (error: string) => void;\r\n  handleImageCrop: (croppedImageBase64: string) => void;\r\n  handleRetry: () => void;\r\n  setCapturedImage: (image: string | null) => void;\r\n  setDetectedCorners: (corners: DocumentCorners | undefined) => void;\r\n}\r\n\r\nexport function useDocumentScanner(\r\n  callbacks: DocumentScannerCallbacks\r\n): UseDocumentScannerReturn {\r\n  const [videoDimensions, setVideoDimensions] = useState(\r\n    DEFAULT_VIDEO_DIMENSIONS\r\n  );\r\n  const [detectedCorners, setDetectedCorners] = useState<\r\n    DocumentCorners | undefined\r\n  >();\r\n  const [capturedImage, setCapturedImage] = useState<string | null>(null);\r\n\r\n  const handleVideoReady = useCallback(\r\n    (dimensions: { width: number; height: number }) => {\r\n      setVideoDimensions(dimensions);\r\n      callbacks.onStatusChange?.(\"scanning\");\r\n      callbacks.onCameraReady?.(dimensions);\r\n    },\r\n    [callbacks]\r\n  );\r\n\r\n  const handleCornersChange = useCallback(\r\n    (newCorners: DocumentCorners) => {\r\n      setDetectedCorners(newCorners);\r\n      callbacks.onCornersChanged?.(newCorners);\r\n    },\r\n    [callbacks]\r\n  );\r\n\r\n  const handleError = useCallback(\r\n    (error: string) => {\r\n      callbacks.onStatusChange?.(\"error\");\r\n      callbacks.onError?.(error);\r\n    },\r\n    [callbacks]\r\n  );\r\n\r\n  const handleImageCrop = useCallback(\r\n    (croppedImageBase64: string) => {\r\n      callbacks.onStatusChange?.(\"cropped\");\r\n      callbacks.onDocumentCropped?.(croppedImageBase64);\r\n    },\r\n    [callbacks]\r\n  );\r\n\r\n  const handleRetry = useCallback(() => {\r\n    setDetectedCorners(undefined);\r\n    setCapturedImage(null);\r\n    callbacks.onStatusChange?.(\"scanning\");\r\n  }, [callbacks]);\r\n\r\n  return {\r\n    videoDimensions,\r\n    detectedCorners,\r\n    capturedImage,\r\n    handleVideoReady,\r\n    handleCornersChange,\r\n    handleError,\r\n    handleImageCrop,\r\n    handleRetry,\r\n    setCapturedImage,\r\n    setDetectedCorners,\r\n  };\r\n}\r\n"],"mappings":"AAAA,SAAS,aAAa,gBAAgB;AAEtC,SAAS,gCAAgC;AAelC,SAAS,mBACd,WAC0B;AAC1B,QAAM,CAAC,iBAAiB,kBAAkB,IAAI;AAAA,IAC5C;AAAA,EACF;AACA,QAAM,CAAC,iBAAiB,kBAAkB,IAAI,SAE5C;AACF,QAAM,CAAC,eAAe,gBAAgB,IAAI,SAAwB,IAAI;AAEtE,QAAM,mBAAmB;AAAA,IACvB,CAAC,eAAkD;AACjD,yBAAmB,UAAU;AAC7B,gBAAU,iBAAiB,UAAU;AACrC,gBAAU,gBAAgB,UAAU;AAAA,IACtC;AAAA,IACA,CAAC,SAAS;AAAA,EACZ;AAEA,QAAM,sBAAsB;AAAA,IAC1B,CAAC,eAAgC;AAC/B,yBAAmB,UAAU;AAC7B,gBAAU,mBAAmB,UAAU;AAAA,IACzC;AAAA,IACA,CAAC,SAAS;AAAA,EACZ;AAEA,QAAM,cAAc;AAAA,IAClB,CAAC,UAAkB;AACjB,gBAAU,iBAAiB,OAAO;AAClC,gBAAU,UAAU,KAAK;AAAA,IAC3B;AAAA,IACA,CAAC,SAAS;AAAA,EACZ;AAEA,QAAM,kBAAkB;AAAA,IACtB,CAAC,uBAA+B;AAC9B,gBAAU,iBAAiB,SAAS;AACpC,gBAAU,oBAAoB,kBAAkB;AAAA,IAClD;AAAA,IACA,CAAC,SAAS;AAAA,EACZ;AAEA,QAAM,cAAc,YAAY,MAAM;AACpC,uBAAmB,MAAS;AAC5B,qBAAiB,IAAI;AACrB,cAAU,iBAAiB,UAAU;AAAA,EACvC,GAAG,CAAC,SAAS,CAAC;AAEd,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;","names":[]}

package/dist/custom/document-scanner/hooks/use-perspective-crop.js

@@ -0,0 +1,31 @@
+import { useCallback } from "react";
+import { perspectiveCorrection } from "../utils/perspective-correction";
+function usePerspectiveCrop({
+  videoDimensions,
+  imageQuality,
+  handleImageCrop,
+  handleError
+}) {
+  return useCallback(
+    async (capturedImage, detectedCorners) => {
+      if (!capturedImage || !detectedCorners) return;
+      try {
+        const croppedImage = await perspectiveCorrection(
+          capturedImage,
+          detectedCorners,
+          videoDimensions,
+          { imageQuality }
+        );
+        handleImageCrop(croppedImage);
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : "Cropping failed";
+        handleError(errorMessage);
+      }
+    },
+    [videoDimensions, imageQuality, handleImageCrop, handleError]
+  );
+}
+export {
+  usePerspectiveCrop
+};
+//# sourceMappingURL=use-perspective-crop.js.map

package/dist/custom/document-scanner/hooks/use-perspective-crop.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/custom/document-scanner/hooks/use-perspective-crop.ts"],"sourcesContent":["import { useCallback } from \"react\";\r\nimport { perspectiveCorrection } from \"../utils/perspective-correction\";\r\nimport { DocumentCorners, Dimensions } from \"../types\";\r\n\r\nexport interface UsePerspectiveCropProps {\r\n  videoDimensions: Dimensions;\r\n  imageQuality: number;\r\n  handleImageCrop: (croppedImageBase64: string) => void;\r\n  handleError: (error: string) => void;\r\n}\r\n\r\nexport function usePerspectiveCrop({\r\n  videoDimensions,\r\n  imageQuality,\r\n  handleImageCrop,\r\n  handleError,\r\n}: UsePerspectiveCropProps) {\r\n  return useCallback(\r\n    async (capturedImage: string, detectedCorners: DocumentCorners) => {\r\n      if (!capturedImage || !detectedCorners) return;\r\n\r\n      try {\r\n        const croppedImage = await perspectiveCorrection(\r\n          capturedImage,\r\n          detectedCorners,\r\n          videoDimensions,\r\n          { imageQuality }\r\n        );\r\n        handleImageCrop(croppedImage);\r\n      } catch (error) {\r\n        const errorMessage =\r\n          error instanceof Error ? error.message : \"Cropping failed\";\r\n        handleError(errorMessage);\r\n      }\r\n    },\r\n    [videoDimensions, imageQuality, handleImageCrop, handleError]\r\n  );\r\n}\r\n"],"mappings":"AAAA,SAAS,mBAAmB;AAC5B,SAAS,6BAA6B;AAU/B,SAAS,mBAAmB;AAAA,EACjC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,GAA4B;AAC1B,SAAO;AAAA,IACL,OAAO,eAAuB,oBAAqC;AACjE,UAAI,CAAC,iBAAiB,CAAC,gBAAiB;AAExC,UAAI;AACF,cAAM,eAAe,MAAM;AAAA,UACzB;AAAA,UACA;AAAA,UACA;AAAA,UACA,EAAE,aAAa;AAAA,QACjB;AACA,wBAAgB,YAAY;AAAA,MAC9B,SAAS,OAAO;AACd,cAAM,eACJ,iBAAiB,QAAQ,MAAM,UAAU;AAC3C,oBAAY,YAAY;AAAA,MAC1B;AAAA,IACF;AAAA,IACA,CAAC,iBAAiB,cAAc,iBAAiB,WAAW;AAAA,EAC9D;AACF;","names":[]}

package/dist/custom/document-scanner/index.js

@@ -0,0 +1,229 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useCallback, useMemo, useState } from "react";
+import { Loader } from "lucide-react";
+import { cn } from "@repo/ayasofyazilim-ui/lib/utils";
+import { Webcam } from "../webcam";
+import {
+  DEFAULT_CAPTURE_INTERVAL,
+  DEFAULT_IMAGE_QUALITY,
+  DEFAULT_MAX_DOCUMENT_SIZE,
+  DEFAULT_MIN_DOCUMENT_SIZE
+} from "./consts";
+import { CornerAdjustment } from "./corner-adjustment";
+import { useDocumentCapture } from "./hooks/use-document-capture";
+import { useDocumentScanner } from "./hooks/use-document-scanner";
+import { usePerspectiveCrop } from "./hooks/use-perspective-crop";
+import { Skeleton } from "@repo/ayasofyazilim-ui/components/skeleton";
+function DocumentScanner({
+  // Core callbacks
+  onDocumentCropped,
+  onDocumentDetected,
+  onCornersChanged,
+  onError,
+  onStatusChange,
+  onCameraReady,
+  onScanAttempt,
+  onImageCapture,
+  // Basic configuration
+  className = "",
+  captureInterval = DEFAULT_CAPTURE_INTERVAL,
+  // Feature toggles
+  allowCrop = true,
+  allowRetry = true,
+  allowCornerAdjustment = true,
+  allowCameraSwitch = true,
+  showWebcamControls = false,
+  // UI Text customization
+  cropButtonText = "Crop",
+  retryButtonText = "Scan Again",
+  // Visual styling
+  cornerColor = "bg-white/80",
+  cornerTouchAreaSize = 20,
+  // Detection settings
+  minDocumentSize = DEFAULT_MIN_DOCUMENT_SIZE,
+  maxDocumentSize = DEFAULT_MAX_DOCUMENT_SIZE,
+  detectionConfidence = 0.8,
+  // Image processing
+  imageQuality = DEFAULT_IMAGE_QUALITY,
+  // Magnifier settings
+  showMagnifier = true,
+  magnifierSize = 60,
+  zoomLevel = 2,
+  // Advanced settings
+  customDetectionAlgorithm,
+  // Custom components
+  customControls,
+  customOverlay,
+  // Webcam interface
+  interfaceLocation = "absolute",
+  showBorder = true
+}) {
+  const [webCamKey, setWebCamKey] = useState(() => Date.now().toString());
+  const [status, setStatus] = useState("scanning");
+  const callbacks = useMemo(
+    () => ({
+      onDocumentCropped,
+      onDocumentDetected,
+      onCornersChanged,
+      onError,
+      onStatusChange: (newStatus) => {
+        setStatus(newStatus);
+        onStatusChange?.(newStatus);
+      },
+      onCameraReady,
+      onScanAttempt,
+      onImageCapture
+    }),
+    [
+      onDocumentCropped,
+      onDocumentDetected,
+      onCornersChanged,
+      onError,
+      onStatusChange,
+      onCameraReady,
+      onScanAttempt,
+      onImageCapture
+    ]
+  );
+  const detectionSettings = useMemo(
+    () => ({
+      minDocumentSize,
+      maxDocumentSize,
+      detectionConfidence
+    }),
+    [minDocumentSize, maxDocumentSize, detectionConfidence]
+  );
+  const {
+    videoDimensions,
+    detectedCorners,
+    capturedImage,
+    handleVideoReady,
+    handleCornersChange,
+    handleError,
+    handleImageCrop,
+    handleRetry: originalHandleRetry,
+    setCapturedImage,
+    setDetectedCorners
+  } = useDocumentScanner(callbacks);
+  const handleRetry = useCallback(() => {
+    originalHandleRetry();
+    setWebCamKey(Date.now().toString());
+  }, [originalHandleRetry]);
+  const handleCapture = useDocumentCapture({
+    videoDimensions,
+    callbacks,
+    customDetectionAlgorithm,
+    detectionSettings,
+    setCapturedImage,
+    setDetectedCorners,
+    handleError
+  });
+  const handleCrop = usePerspectiveCrop({
+    videoDimensions,
+    imageQuality,
+    handleImageCrop,
+    handleError
+  });
+  const webcamCallbacks = useMemo(
+    () => ({
+      onWebcamReady: handleVideoReady,
+      onAutoPhotoCaptured: handleCapture
+    }),
+    [handleVideoReady, handleCapture]
+  );
+  const webcamClassNames = useMemo(
+    () => ({
+      placeholder: "block"
+    }),
+    []
+  );
+  const webcamAutoCapture = useMemo(
+    () => ({
+      captureInterval,
+      hasInterface: showWebcamControls,
+      startOnReady: true,
+      quality: imageQuality,
+      stopOnCapture: true
+    }),
+    [captureInterval, imageQuality, showWebcamControls]
+  );
+  const webcamPlaceholder = useMemo(() => {
+    if (status === "scanning") {
+      return /* @__PURE__ */ jsx(Skeleton, { className: "w-full h-full bg-white/50 flex items-center justify-center", children: /* @__PURE__ */ jsx(Loader, { className: "size-4 animate-spin" }) });
+    }
+    if (detectedCorners && capturedImage && allowCornerAdjustment) {
+      return /* @__PURE__ */ jsx(
+        CornerAdjustment,
+        {
+          capturedImage,
+          detectedCorners,
+          videoDimensions,
+          onCornersChange: handleCornersChange,
+          onCrop: () => handleCrop(capturedImage, detectedCorners),
+          onRetry: handleRetry,
+          cornerColor,
+          cornerTouchAreaSize,
+          allowCrop,
+          allowRetry,
+          cropButtonText,
+          retryButtonText,
+          showMagnifier,
+          magnifierSize,
+          zoomLevel
+        }
+      );
+    }
+    return void 0;
+  }, [
+    status,
+    detectedCorners,
+    allowCornerAdjustment,
+    videoDimensions,
+    capturedImage,
+    cornerTouchAreaSize,
+    cornerColor,
+    handleCornersChange,
+    handleCrop,
+    handleRetry,
+    allowCrop,
+    allowRetry,
+    cropButtonText,
+    retryButtonText,
+    showMagnifier,
+    magnifierSize,
+    zoomLevel
+  ]);
+  const isInCornerAdjustmentMode = detectedCorners && capturedImage && allowCornerAdjustment || false;
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: cn(
+        "container relative mx-auto max-w-3xl overflow-hidden p-4",
+        className
+      ),
+      children: [
+        customOverlay,
+        /* @__PURE__ */ jsx(
+          Webcam,
+          {
+            classNames: webcamClassNames,
+            callbacks: webcamCallbacks,
+            defaultCamera: "back",
+            autoCapture: webcamAutoCapture,
+            allowCameraSwitch,
+            placeholder: webcamPlaceholder,
+            interfaceLocation,
+            showBorder,
+            forceHideInterface: isInCornerAdjustmentMode
+          },
+          webCamKey
+        ),
+        customControls && /* @__PURE__ */ jsx("div", { className: "mt-4", children: customControls })
+      ]
+    }
+  );
+}
+export {
+  DocumentScanner
+};
+//# sourceMappingURL=index.js.map

package/dist/custom/document-scanner/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/custom/document-scanner/index.tsx"],"sourcesContent":["import { useCallback, useMemo, useState } from \"react\";\r\nimport { Loader } from \"lucide-react\";\r\nimport { cn } from \"@repo/ayasofyazilim-ui/lib/utils\";\r\nimport { Webcam } from \"../webcam\";\r\nimport {\r\n  DEFAULT_CAPTURE_INTERVAL,\r\n  DEFAULT_IMAGE_QUALITY,\r\n  DEFAULT_MAX_DOCUMENT_SIZE,\r\n  DEFAULT_MIN_DOCUMENT_SIZE,\r\n} from \"./consts\";\r\nimport { CornerAdjustment } from \"./corner-adjustment\";\r\nimport { useDocumentCapture } from \"./hooks/use-document-capture\";\r\nimport { useDocumentScanner } from \"./hooks/use-document-scanner\";\r\nimport { usePerspectiveCrop } from \"./hooks/use-perspective-crop\";\r\nimport { DocumentScannerProps, ScannerStatus } from \"./types\";\r\nimport { Skeleton } from \"@repo/ayasofyazilim-ui/components/skeleton\";\r\n\r\nexport function DocumentScanner({\r\n  // Core callbacks\r\n  onDocumentCropped,\r\n  onDocumentDetected,\r\n  onCornersChanged,\r\n  onError,\r\n  onStatusChange,\r\n  onCameraReady,\r\n  onScanAttempt,\r\n  onImageCapture,\r\n\r\n  // Basic configuration\r\n  className = \"\",\r\n  captureInterval = DEFAULT_CAPTURE_INTERVAL,\r\n\r\n  // Feature toggles\r\n  allowCrop = true,\r\n  allowRetry = true,\r\n  allowCornerAdjustment = true,\r\n  allowCameraSwitch = true,\r\n  showWebcamControls = false,\r\n\r\n  // UI Text customization\r\n  cropButtonText = \"Crop\",\r\n  retryButtonText = \"Scan Again\",\r\n\r\n  // Visual styling\r\n  cornerColor = \"bg-white/80\",\r\n  cornerTouchAreaSize = 20,\r\n\r\n  // Detection settings\r\n  minDocumentSize = DEFAULT_MIN_DOCUMENT_SIZE,\r\n  maxDocumentSize = DEFAULT_MAX_DOCUMENT_SIZE,\r\n  detectionConfidence = 0.8,\r\n\r\n  // Image processing\r\n  imageQuality = DEFAULT_IMAGE_QUALITY,\r\n\r\n  // Magnifier settings\r\n  showMagnifier = true,\r\n  magnifierSize = 60,\r\n  zoomLevel = 2,\r\n\r\n  // Advanced settings\r\n  customDetectionAlgorithm,\r\n\r\n  // Custom components\r\n  customControls,\r\n  customOverlay,\r\n\r\n  // Webcam interface\r\n  interfaceLocation = \"absolute\",\r\n  showBorder = true,\r\n}: DocumentScannerProps) {\r\n  const [webCamKey, setWebCamKey] = useState(() => Date.now().toString());\r\n  const [status, setStatus] = useState<ScannerStatus>(\"scanning\");\r\n\r\n  // Combine callbacks for hooks\r\n  const callbacks = useMemo(\r\n    () => ({\r\n      onDocumentCropped,\r\n      onDocumentDetected,\r\n      onCornersChanged,\r\n      onError,\r\n      onStatusChange: (newStatus: ScannerStatus) => {\r\n        setStatus(newStatus);\r\n        onStatusChange?.(newStatus);\r\n      },\r\n      onCameraReady,\r\n      onScanAttempt,\r\n      onImageCapture,\r\n    }),\r\n    [\r\n      onDocumentCropped,\r\n      onDocumentDetected,\r\n      onCornersChanged,\r\n      onError,\r\n      onStatusChange,\r\n      onCameraReady,\r\n      onScanAttempt,\r\n      onImageCapture,\r\n    ]\r\n  );\r\n\r\n  // Detection settings\r\n  const detectionSettings = useMemo(\r\n    () => ({\r\n      minDocumentSize,\r\n      maxDocumentSize,\r\n      detectionConfidence,\r\n    }),\r\n    [minDocumentSize, maxDocumentSize, detectionConfidence]\r\n  );\r\n\r\n  // Main document scanner state\r\n  const {\r\n    videoDimensions,\r\n    detectedCorners,\r\n    capturedImage,\r\n    handleVideoReady,\r\n    handleCornersChange,\r\n    handleError,\r\n    handleImageCrop,\r\n    handleRetry: originalHandleRetry,\r\n    setCapturedImage,\r\n    setDetectedCorners,\r\n  } = useDocumentScanner(callbacks);\r\n\r\n  // Enhanced retry handler that resets webcam\r\n  const handleRetry = useCallback(() => {\r\n    originalHandleRetry();\r\n    setWebCamKey(Date.now().toString());\r\n  }, [originalHandleRetry]);\r\n\r\n  // Document capture logic\r\n  const handleCapture = useDocumentCapture({\r\n    videoDimensions,\r\n    callbacks,\r\n    customDetectionAlgorithm,\r\n    detectionSettings,\r\n    setCapturedImage,\r\n    setDetectedCorners,\r\n    handleError,\r\n  });\r\n\r\n  // Perspective cropping logic\r\n  const handleCrop = usePerspectiveCrop({\r\n    videoDimensions,\r\n    imageQuality,\r\n    handleImageCrop,\r\n    handleError,\r\n  });\r\n\r\n  // Webcam configuration\r\n  const webcamCallbacks = useMemo(\r\n    () => ({\r\n      onWebcamReady: handleVideoReady,\r\n      onAutoPhotoCaptured: handleCapture,\r\n    }),\r\n    [handleVideoReady, handleCapture]\r\n  );\r\n\r\n  const webcamClassNames = useMemo(\r\n    () => ({\r\n      placeholder: \"block\",\r\n    }),\r\n    []\r\n  );\r\n\r\n  const webcamAutoCapture = useMemo(\r\n    () => ({\r\n      captureInterval,\r\n      hasInterface: showWebcamControls,\r\n      startOnReady: true,\r\n      quality: imageQuality,\r\n      stopOnCapture: true,\r\n    }),\r\n    [captureInterval, imageQuality, showWebcamControls]\r\n  );\r\n\r\n  const webcamPlaceholder = useMemo(() => {\r\n    if (status === \"scanning\") {\r\n      return (\r\n        <Skeleton className=\"w-full h-full bg-white/50 flex items-center justify-center\">\r\n          <Loader className=\"size-4 animate-spin\" />\r\n        </Skeleton>\r\n      );\r\n    }\r\n    if (detectedCorners && capturedImage && allowCornerAdjustment) {\r\n      return (\r\n        <CornerAdjustment\r\n          capturedImage={capturedImage}\r\n          detectedCorners={detectedCorners}\r\n          videoDimensions={videoDimensions}\r\n          onCornersChange={handleCornersChange}\r\n          onCrop={() => handleCrop(capturedImage, detectedCorners)}\r\n          onRetry={handleRetry}\r\n          cornerColor={cornerColor}\r\n          cornerTouchAreaSize={cornerTouchAreaSize}\r\n          allowCrop={allowCrop}\r\n          allowRetry={allowRetry}\r\n          cropButtonText={cropButtonText}\r\n          retryButtonText={retryButtonText}\r\n          showMagnifier={showMagnifier}\r\n          magnifierSize={magnifierSize}\r\n          zoomLevel={zoomLevel}\r\n        />\r\n      );\r\n    }\r\n\r\n    return undefined;\r\n  }, [\r\n    status,\r\n    detectedCorners,\r\n    allowCornerAdjustment,\r\n    videoDimensions,\r\n    capturedImage,\r\n    cornerTouchAreaSize,\r\n    cornerColor,\r\n    handleCornersChange,\r\n    handleCrop,\r\n    handleRetry,\r\n    allowCrop,\r\n    allowRetry,\r\n    cropButtonText,\r\n    retryButtonText,\r\n    showMagnifier,\r\n    magnifierSize,\r\n    zoomLevel,\r\n  ]);\r\n\r\n  const isInCornerAdjustmentMode =\r\n    (detectedCorners && capturedImage && allowCornerAdjustment) || false;\r\n\r\n  return (\r\n    <div\r\n      className={cn(\r\n        \"container relative mx-auto max-w-3xl overflow-hidden p-4\",\r\n        className\r\n      )}\r\n    >\r\n      {customOverlay}\r\n      <Webcam\r\n        key={webCamKey}\r\n        classNames={webcamClassNames}\r\n        callbacks={webcamCallbacks}\r\n        defaultCamera=\"back\"\r\n        autoCapture={webcamAutoCapture}\r\n        allowCameraSwitch={allowCameraSwitch}\r\n        placeholder={webcamPlaceholder}\r\n        interfaceLocation={interfaceLocation}\r\n        showBorder={showBorder}\r\n        forceHideInterface={isInCornerAdjustmentMode}\r\n      />\r\n      {customControls && <div className=\"mt-4\">{customControls}</div>}\r\n    </div>\r\n  );\r\n}\r\n"],"mappings":"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","names":[]}

package/dist/custom/document-scanner/lib.js

@@ -0,0 +1,289 @@
+import { createScanner } from "../tscanify/browser";
+import { DEFAULT_MAX_DOCUMENT_SIZE, DEFAULT_MIN_DOCUMENT_SIZE } from "./consts";
+import cv from "opencv-ts";
+async function scanDocument(imageBase64, videoDimensions, onSuccess, onError, options) {
+  try {
+    const scanner = createScanner();
+    const inputCanvas = document.createElement("canvas");
+    const img = new Image();
+    await new Promise((resolve, reject) => {
+      img.onload = () => {
+        try {
+          const ctx = inputCanvas.getContext("2d");
+          if (!ctx) {
+            reject(new Error("Failed to get canvas context"));
+            return;
+          }
+          inputCanvas.width = img.width;
+          inputCanvas.height = img.height;
+          ctx.drawImage(img, 0, 0);
+          const src = cv.imread(inputCanvas);
+          let detectedCorners = null;
+          try {
+            const minDocumentSize = options?.minDocumentSize ?? DEFAULT_MIN_DOCUMENT_SIZE;
+            const maxDocumentSize = options?.maxDocumentSize ?? DEFAULT_MAX_DOCUMENT_SIZE;
+            detectedCorners = findDocumentSimple(src, img.width, img.height);
+            if (!detectedCorners) {
+              detectedCorners = scanner.findDocumentCorners(src);
+            }
+            if (!detectedCorners) {
+              detectedCorners = findDocumentCornersAdvanced(
+                src,
+                img.width,
+                img.height
+              );
+            }
+            if (detectedCorners) {
+              const {
+                topLeftCorner,
+                topRightCorner,
+                bottomRightCorner,
+                bottomLeftCorner
+              } = detectedCorners;
+              const width = Math.abs(topRightCorner.x - topLeftCorner.x);
+              const height = Math.abs(bottomLeftCorner.y - topLeftCorner.y);
+              const minSize = Math.min(img.width, img.height) * minDocumentSize;
+              const maxSize = Math.min(img.width, img.height) * maxDocumentSize;
+              if (width >= minSize && height >= minSize && width <= maxSize && height <= maxSize) {
+                const scaledCorners = {
+                  topLeftCorner: {
+                    x: topLeftCorner.x / img.width * videoDimensions.width,
+                    y: topLeftCorner.y / img.height * videoDimensions.height
+                  },
+                  topRightCorner: {
+                    x: topRightCorner.x / img.width * videoDimensions.width,
+                    y: topRightCorner.y / img.height * videoDimensions.height
+                  },
+                  bottomRightCorner: {
+                    x: bottomRightCorner.x / img.width * videoDimensions.width,
+                    y: bottomRightCorner.y / img.height * videoDimensions.height
+                  },
+                  bottomLeftCorner: {
+                    x: bottomLeftCorner.x / img.width * videoDimensions.width,
+                    y: bottomLeftCorner.y / img.height * videoDimensions.height
+                  }
+                };
+                onSuccess(scaledCorners);
+              }
+            }
+          } finally {
+            src.delete();
+          }
+          resolve();
+        } catch (error) {
+          reject(error);
+        }
+      };
+      img.onerror = () => reject(new Error("Failed to load image"));
+      img.src = imageBase64;
+    });
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error occurred during document scanning";
+    onError(errorMessage);
+  }
+}
+function findDocumentSimple(src, width, height) {
+  try {
+    const gray = new cv.Mat();
+    const binary = new cv.Mat();
+    cv.cvtColor(src, gray, cv.COLOR_RGBA2GRAY);
+    cv.threshold(gray, binary, 0, 255, cv.THRESH_BINARY + cv.THRESH_OTSU);
+    const contours = new cv.MatVector();
+    const hierarchy = new cv.Mat();
+    cv.findContours(
+      binary,
+      contours,
+      hierarchy,
+      cv.RETR_EXTERNAL,
+      cv.CHAIN_APPROX_SIMPLE
+    );
+    for (let i = 0; i < contours.size(); i++) {
+      const contour = contours.get(i);
+      const area = cv.contourArea(contour);
+      const minArea = width * height * 0.1;
+      if (area > minArea) {
+        const approx = new cv.Mat();
+        const peri = cv.arcLength(contour, true);
+        cv.approxPolyDP(contour, approx, 0.02 * peri, true);
+        if (approx.rows === 4) {
+          const points = [];
+          for (let j = 0; j < 4; j++) {
+            const point = approx.data32S;
+            points.push({ x: point[j * 2] || 0, y: point[j * 2 + 1] || 0 });
+          }
+          points.sort((a, b) => a.y - b.y);
+          const topPoints = points.slice(0, 2).sort((a, b) => a.x - b.x);
+          const bottomPoints = points.slice(2, 4).sort((a, b) => a.x - b.x);
+          const corners = {
+            topLeftCorner: topPoints[0],
+            topRightCorner: topPoints[1],
+            bottomRightCorner: bottomPoints[1],
+            bottomLeftCorner: bottomPoints[0]
+          };
+          approx.delete();
+          contour.delete();
+          gray.delete();
+          binary.delete();
+          contours.delete();
+          hierarchy.delete();
+          return corners;
+        }
+        approx.delete();
+      }
+      contour.delete();
+    }
+    gray.delete();
+    binary.delete();
+    contours.delete();
+    hierarchy.delete();
+    return null;
+  } catch {
+    return null;
+  }
+}
+function findDocumentCornersAdvanced(src, width, height) {
+  try {
+    const gray = new cv.Mat();
+    cv.cvtColor(src, gray, cv.COLOR_RGBA2GRAY);
+    const approaches = [
+      {
+        name: "OTSU + Gaussian",
+        process: (input) => {
+          const blurred = new cv.Mat();
+          const binary = new cv.Mat();
+          cv.GaussianBlur(input, blurred, new cv.Size(9, 9), 0, 0, 0);
+          cv.threshold(
+            blurred,
+            binary,
+            0,
+            255,
+            cv.THRESH_BINARY + cv.THRESH_OTSU
+          );
+          blurred.delete();
+          return binary;
+        }
+      },
+      {
+        name: "Adaptive Threshold",
+        process: (input) => {
+          const binary = new cv.Mat();
+          cv.adaptiveThreshold(
+            input,
+            binary,
+            255,
+            cv.ADAPTIVE_THRESH_GAUSSIAN_C,
+            cv.THRESH_BINARY,
+            15,
+            10
+          );
+          return binary;
+        }
+      }
+    ];
+    let bestCorners = null;
+    let bestScore = 0;
+    Array.from(approaches).forEach((approach) => {
+      const binary = approach.process(gray);
+      const corners = findCornersFromBinary(binary, width, height);
+      if (corners) {
+        const score = scoreCornersQuality(corners, width, height);
+        if (score > bestScore) {
+          bestScore = score;
+          bestCorners = corners;
+        }
+      }
+      binary.delete();
+    });
+    gray.delete();
+    return bestCorners;
+  } catch {
+    return null;
+  }
+}
+function findCornersFromBinary(binary, width, height) {
+  try {
+    const contours = new cv.MatVector();
+    const hierarchy = new cv.Mat();
+    cv.findContours(
+      binary,
+      contours,
+      hierarchy,
+      cv.RETR_EXTERNAL,
+      cv.CHAIN_APPROX_SIMPLE
+    );
+    let bestCorners = null;
+    let bestArea = 0;
+    for (let i = 0; i < contours.size(); i++) {
+      const contour = contours.get(i);
+      const area = cv.contourArea(contour);
+      const minArea = width * height * 0.05;
+      if (area > minArea && area > bestArea) {
+        const approx = new cv.Mat();
+        const peri = cv.arcLength(contour, true);
+        cv.approxPolyDP(contour, approx, 0.02 * peri, true);
+        if (approx.rows === 4) {
+          const points = [];
+          for (let j = 0; j < 4; j++) {
+            const point = approx.data32S;
+            points.push({ x: point[j * 2] || 0, y: point[j * 2 + 1] || 0 });
+          }
+          points.sort((a, b) => a.y - b.y);
+          const topPoints = points.slice(0, 2).sort((a, b) => a.x - b.x);
+          const bottomPoints = points.slice(2, 4).sort((a, b) => a.x - b.x);
+          bestCorners = {
+            topLeftCorner: topPoints[0],
+            topRightCorner: topPoints[1],
+            bottomRightCorner: bottomPoints[1],
+            bottomLeftCorner: bottomPoints[0]
+          };
+          bestArea = area;
+        }
+        approx.delete();
+      }
+      contour.delete();
+    }
+    contours.delete();
+    hierarchy.delete();
+    return bestCorners;
+  } catch {
+    return null;
+  }
+}
+function scoreCornersQuality(corners, width, height) {
+  try {
+    const {
+      topLeftCorner,
+      topRightCorner,
+      bottomRightCorner,
+      bottomLeftCorner
+    } = corners;
+    const topWidth = Math.abs(topRightCorner.x - topLeftCorner.x);
+    const bottomWidth = Math.abs(bottomRightCorner.x - bottomLeftCorner.x);
+    const leftHeight = Math.abs(bottomLeftCorner.y - topLeftCorner.y);
+    const rightHeight = Math.abs(bottomRightCorner.y - topRightCorner.y);
+    const avgWidth = (topWidth + bottomWidth) / 2;
+    const avgHeight = (leftHeight + rightHeight) / 2;
+    const area = avgWidth * avgHeight;
+    const widthDifference = Math.abs(topWidth - bottomWidth) / Math.max(topWidth, bottomWidth);
+    const heightDifference = Math.abs(leftHeight - rightHeight) / Math.max(leftHeight, rightHeight);
+    const rectangularityScore = 1 - (widthDifference + heightDifference) / 2;
+    const maxArea = width * height;
+    const areaScore = Math.min(area / (maxArea * 0.8), 1);
+    const aspectRatio = avgWidth / avgHeight;
+    const aspectScore = aspectRatio > 0.3 && aspectRatio < 3 ? 1 : 0.5;
+    const minSize = Math.min(width, height) * 0.15;
+    const maxSize = Math.min(width, height) * 0.95;
+    const sizeScore = avgWidth >= minSize && avgHeight >= minSize && avgWidth <= maxSize && avgHeight <= maxSize ? 1 : 0.3;
+    return areaScore * 0.3 + rectangularityScore * 0.4 + aspectScore * 0.2 + sizeScore * 0.1;
+  } catch {
+    return 0;
+  }
+}
+export {
+  findCornersFromBinary,
+  findDocumentCornersAdvanced,
+  findDocumentSimple,
+  scanDocument,
+  scoreCornersQuality
+};
+//# sourceMappingURL=lib.js.map