id-scanner-lib 1.0.0 → 1.2.0

package/dist/id-scanner-qr.esm.js

@@ -0,0 +1,773 @@
+import jsQR from 'jsqr';
+
+/**
+ * @file 相机工具类
+ * @description 提供访问和控制设备摄像头的功能
+ * @module Camera
+ */
+/**
+ * 相机工具类
+ *
+ * 提供访问设备摄像头、获取视频流以及捕获图像帧的功能
+ *
+ * @example
+ * ```typescript
+ * // 创建相机实例
+ * const camera = new Camera({
+ *   width: 1280,
+ *   height: 720,
+ *   facingMode: 'environment' // 使用后置摄像头
+ * });
+ *
+ * // 初始化相机
+ * const videoElement = document.getElementById('video') as HTMLVideoElement;
+ * await camera.start(videoElement);
+ *
+ * // 捕获当前视频帧
+ * const imageData = camera.captureFrame();
+ *
+ * // 使用结束后释放资源
+ * camera.stop();
+ * ```
+ */
+class Camera {
+    /**
+     * 创建相机实例
+     * @param {CameraOptions} [options] - 相机配置选项
+     */
+    constructor(options = {}) {
+        this.options = options;
+        this.stream = null;
+        this.videoElement = null;
+        this.options = {
+            width: 640,
+            height: 480,
+            facingMode: 'environment',
+            ...options
+        };
+    }
+    /**
+     * 启动摄像头并将视频流绑定到视频元素
+     * @param videoElement HTML视频元素
+     * @returns Promise<void>
+     */
+    async start(videoElement) {
+        return this.initialize(videoElement);
+    }
+    /**
+     * 停止摄像头并释放资源
+     */
+    stop() {
+        this.release();
+    }
+    /**
+     * 初始化相机，获取视频流并绑定到视频元素
+     *
+     * @param {HTMLVideoElement} videoElement - 用于显示视频流的视频元素
+     * @returns {Promise<void>} 初始化完成的Promise
+     * @throws 如果无法访问摄像头，将抛出错误
+     */
+    async initialize(videoElement) {
+        this.videoElement = videoElement;
+        try {
+            // 构建媒体约束
+            const constraints = {
+                video: {
+                    width: { ideal: this.options.width },
+                    height: { ideal: this.options.height },
+                    facingMode: this.options.facingMode
+                }
+            };
+            // 获取视频流
+            this.stream = await navigator.mediaDevices.getUserMedia(constraints);
+            // 绑定到视频元素
+            if (this.videoElement) {
+                this.videoElement.srcObject = this.stream;
+                await new Promise((resolve) => {
+                    if (this.videoElement) {
+                        this.videoElement.onloadedmetadata = () => {
+                            if (this.videoElement) {
+                                this.videoElement.play().then(() => resolve());
+                            }
+                        };
+                    }
+                });
+            }
+        }
+        catch (error) {
+            console.error('无法访问摄像头:', error);
+            throw new Error('无法访问摄像头。请确保已授予摄像头访问权限，并且摄像头未被其他应用程序占用。');
+        }
+    }
+    /**
+     * 捕获当前视频帧
+     *
+     * @returns {ImageData|null} 视频帧的ImageData对象，如果未初始化则返回null
+     */
+    captureFrame() {
+        if (!this.videoElement) {
+            return null;
+        }
+        // 创建Canvas元素用于捕获视频帧
+        const canvas = document.createElement('canvas');
+        canvas.width = this.videoElement.videoWidth;
+        canvas.height = this.videoElement.videoHeight;
+        const context = canvas.getContext('2d');
+        if (!context) {
+            return null;
+        }
+        // 将视频内容绘制到Canvas中
+        context.drawImage(this.videoElement, 0, 0, canvas.width, canvas.height);
+        // 获取ImageData对象
+        return context.getImageData(0, 0, canvas.width, canvas.height);
+    }
+    /**
+     * 释放摄像头资源
+     */
+    release() {
+        // 停止视频流的所有轨道
+        if (this.stream) {
+            this.stream.getTracks().forEach(track => track.stop());
+            this.stream = null;
+        }
+        // 清除视频元素绑定
+        if (this.videoElement) {
+            this.videoElement.srcObject = null;
+            this.videoElement = null;
+        }
+    }
+}
+
+/**
+ * @file 二维码扫描模块
+ * @description 提供实时二维码扫描和识别功能
+ * @module QRScanner
+ */
+/**
+ * 二维码扫描器类
+ *
+ * 提供实时扫描和识别摄像头中的二维码的功能
+ *
+ * @example
+ * ```typescript
+ * // 创建二维码扫描器
+ * const qrScanner = new QRScanner({
+ *   scanInterval: 100, // 每100ms扫描一次
+ *   onScan: (result) => {
+ *     console.log('扫描到二维码:', result);
+ *   },
+ *   onError: (error) => {
+ *     console.error('扫描错误:', error);
+ *   }
+ * });
+ *
+ * // 启动扫描
+ * const videoElement = document.getElementById('video') as HTMLVideoElement;
+ * await qrScanner.start(videoElement);
+ *
+ * // 停止扫描
+ * qrScanner.stop();
+ * ```
+ */
+class QRScanner {
+    /**
+     * 创建二维码扫描器实例
+     *
+     * @param {QRScannerOptions} [options] - 扫描器配置选项
+     */
+    constructor(options = {}) {
+        this.options = options;
+        this.scanning = false;
+        this.scanTimer = null;
+        this.options = {
+            scanInterval: 200,
+            ...options
+        };
+        this.camera = new Camera();
+    }
+    /**
+     * 启动二维码扫描
+     *
+     * 初始化相机并开始连续扫描视频帧中的二维码
+     *
+     * @param {HTMLVideoElement} videoElement - 用于显示相机画面的video元素
+     * @returns {Promise<void>} 启动完成的Promise
+     * @throws 如果无法访问相机，将通过onError回调报告错误
+     */
+    async start(videoElement) {
+        try {
+            await this.camera.initialize(videoElement);
+            this.scanning = true;
+            this.scan();
+        }
+        catch (error) {
+            if (this.options.onError) {
+                this.options.onError(error instanceof Error ? error : new Error(String(error)));
+            }
+        }
+    }
+    /**
+     * 执行一次二维码扫描
+     *
+     * 内部方法，捕获当前视频帧并尝试识别其中的二维码
+     *
+     * @private
+     */
+    scan() {
+        if (!this.scanning)
+            return;
+        const imageData = this.camera.captureFrame();
+        if (imageData) {
+            const code = jsQR(imageData.data, imageData.width, imageData.height);
+            if (code && this.options.onScan) {
+                this.options.onScan(code.data);
+            }
+        }
+        this.scanTimer = window.setTimeout(() => this.scan(), this.options.scanInterval);
+    }
+    /**
+     * 停止二维码扫描
+     *
+     * 停止扫描循环并释放相机资源
+     */
+    stop() {
+        this.scanning = false;
+        if (this.scanTimer) {
+            clearTimeout(this.scanTimer);
+            this.scanTimer = null;
+        }
+        this.camera.release();
+    }
+}
+
+/**
+ * @file 图像处理工具类
+ * @description 提供图像处理相关的辅助功能
+ * @module ImageProcessor
+ */
+/**
+ * 图像处理工具类
+ *
+ * 提供常用的图像处理功能，如亮度和对比度调整、灰度转换、图像大小调整等。
+ * 这些功能可用于增强图像质量，提高OCR和扫描的识别率。
+ *
+ * @example
+ * ```typescript
+ * // 使用图像处理功能增强图像
+ * const enhancedImage = ImageProcessor.adjustBrightnessContrast(
+ *   originalImageData,
+ *   15,  // 增加亮度
+ *   25   // 增加对比度
+ * );
+ *
+ * // 转换为灰度图像
+ * const grayImage = ImageProcessor.toGrayscale(originalImageData);
+ * ```
+ */
+class ImageProcessor {
+    /**
+     * 将ImageData转换为Canvas元素
+     *
+     * @param {ImageData} imageData - 要转换的图像数据
+     * @returns {HTMLCanvasElement} 包含图像的Canvas元素
+     */
+    static imageDataToCanvas(imageData) {
+        const canvas = document.createElement('canvas');
+        canvas.width = imageData.width;
+        canvas.height = imageData.height;
+        const ctx = canvas.getContext('2d');
+        if (ctx) {
+            ctx.putImageData(imageData, 0, 0);
+        }
+        return canvas;
+    }
+    /**
+     * 将Canvas转换为ImageData
+     *
+     * @param {HTMLCanvasElement} canvas - 要转换的Canvas元素
+     * @returns {ImageData|null} Canvas的图像数据，如果获取失败则返回null
+     */
+    static canvasToImageData(canvas) {
+        const ctx = canvas.getContext('2d');
+        return ctx ? ctx.getImageData(0, 0, canvas.width, canvas.height) : null;
+    }
+    /**
+     * 调整图像亮度和对比度
+     *
+     * @param {ImageData} imageData - 要处理的图像数据
+     * @param {number} [brightness=0] - 亮度调整值，正值增加亮度，负值降低亮度，范围建议为-100到100
+     * @param {number} [contrast=0] - 对比度调整值，正值增加对比度，负值降低对比度，范围建议为-100到100
+     * @returns {ImageData} 处理后的图像数据
+     */
+    static adjustBrightnessContrast(imageData, brightness = 0, contrast = 0) {
+        const canvas = this.imageDataToCanvas(imageData);
+        const ctx = canvas.getContext('2d');
+        if (ctx) {
+            const imgData = ctx.getImageData(0, 0, canvas.width, canvas.height);
+            const data = imgData.data;
+            // 调整对比度算法
+            const factor = (259 * (contrast + 255)) / (255 * (259 - contrast));
+            for (let i = 0; i < data.length; i += 4) {
+                // 红色
+                data[i] = this.truncate(factor * (data[i] - 128) + 128 + brightness);
+                // 绿色
+                data[i + 1] = this.truncate(factor * (data[i + 1] - 128) + 128 + brightness);
+                // 蓝色
+                data[i + 2] = this.truncate(factor * (data[i + 2] - 128) + 128 + brightness);
+                // Alpha不变
+            }
+            ctx.putImageData(imgData, 0, 0);
+            return imgData;
+        }
+        return imageData;
+    }
+    /**
+     * 确保值在0-255范围内
+     *
+     * @private
+     * @param {number} value - 要截断的值
+     * @returns {number} 截断后的值，范围为0-255
+     */
+    static truncate(value) {
+        return Math.min(255, Math.max(0, value));
+    }
+    /**
+     * 将彩色图像转换为灰度图像
+     *
+     * 灰度转换可以简化图像，提高OCR和条形码识别的准确率
+     *
+     * @param {ImageData} imageData - 要转换的彩色图像
+     * @returns {ImageData} 转换后的灰度图像
+     */
+    static toGrayscale(imageData) {
+        const canvas = this.imageDataToCanvas(imageData);
+        const ctx = canvas.getContext('2d');
+        if (ctx) {
+            const imgData = ctx.getImageData(0, 0, canvas.width, canvas.height);
+            const data = imgData.data;
+            for (let i = 0; i < data.length; i += 4) {
+                const avg = (data[i] + data[i + 1] + data[i + 2]) / 3;
+                data[i] = avg; // 红色
+                data[i + 1] = avg; // 绿色
+                data[i + 2] = avg; // 蓝色
+                // Alpha不变
+            }
+            ctx.putImageData(imgData, 0, 0);
+            return imgData;
+        }
+        return imageData;
+    }
+    /**
+     * 调整图像大小
+     *
+     * @param {ImageData} imageData - 原图像数据
+     * @param {number} newWidth - 新宽度
+     * @param {number} newHeight - 新高度
+     * @returns {ImageData} 调整大小后的图像数据
+     */
+    static resize(imageData, newWidth, newHeight) {
+        const canvas = document.createElement('canvas');
+        canvas.width = newWidth;
+        canvas.height = newHeight;
+        const ctx = canvas.getContext('2d');
+        if (ctx) {
+            const tempCanvas = this.imageDataToCanvas(imageData);
+            ctx.drawImage(tempCanvas, 0, 0, imageData.width, imageData.height, 0, 0, newWidth, newHeight);
+            return ctx.getImageData(0, 0, newWidth, newHeight);
+        }
+        return imageData;
+    }
+    /**
+     * 降低图像分辨率以提高处理速度
+     *
+     * 对于OCR和图像分析，降低分辨率可以在保持识别率的同时大幅提升处理速度
+     *
+     * @param {ImageData} imageData - 原图像数据
+     * @param {number} [maxDimension=1000] - 目标最大尺寸（宽或高）
+     * @returns {ImageData} 处理后的图像数据
+     */
+    static downsampleForProcessing(imageData, maxDimension = 1000) {
+        const { width, height } = imageData;
+        // 如果图像尺寸已经小于或等于目标尺寸，则无需处理
+        if (width <= maxDimension && height <= maxDimension) {
+            return imageData;
+        }
+        // 计算缩放比例，保持宽高比
+        const scale = maxDimension / Math.max(width, height);
+        const newWidth = Math.round(width * scale);
+        const newHeight = Math.round(height * scale);
+        // 调整图像大小
+        return this.resize(imageData, newWidth, newHeight);
+    }
+    /**
+     * 转换图像为Base64格式，方便在Worker线程中传递
+     *
+     * @param {ImageData} imageData - 原图像数据
+     * @returns {string} base64编码的图像数据
+     */
+    static imageDataToBase64(imageData) {
+        const canvas = this.imageDataToCanvas(imageData);
+        return canvas.toDataURL('image/jpeg', 0.7); // 使用较低质量的JPEG格式减少数据量
+    }
+    /**
+     * 从Base64字符串还原图像数据
+     *
+     * @param {string} base64 - base64编码的图像数据
+     * @returns {Promise<ImageData>} 还原的图像数据
+     */
+    static async base64ToImageData(base64) {
+        return new Promise((resolve, reject) => {
+            const img = new Image();
+            img.onload = () => {
+                const canvas = document.createElement('canvas');
+                canvas.width = img.width;
+                canvas.height = img.height;
+                const ctx = canvas.getContext('2d');
+                if (!ctx) {
+                    reject(new Error('无法创建Canvas上下文'));
+                    return;
+                }
+                ctx.drawImage(img, 0, 0);
+                const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height);
+                resolve(imageData);
+            };
+            img.onerror = () => {
+                reject(new Error('图像加载失败'));
+            };
+            img.src = base64;
+        });
+    }
+    /**
+     * 使用Web Worker并行处理图像
+     * 此方法将图像分割为多个部分，并行处理以提高性能
+     *
+     * @param {ImageData} imageData - 原图像数据
+     * @param {Function} processingFunction - 处理函数，接收ImageData返回ImageData
+     * @param {number} [chunks=4] - 分割的块数
+     * @returns {Promise<ImageData>} 处理后的图像数据
+     */
+    static async processImageInParallel(imageData, processingFunction, chunks = 4) {
+        // 如果不支持Worker或图像太小，直接处理
+        if (typeof Worker === 'undefined' || imageData.width * imageData.height < 100000) {
+            return processingFunction(imageData);
+        }
+        // 创建结果canvas
+        const resultCanvas = document.createElement('canvas');
+        resultCanvas.width = imageData.width;
+        resultCanvas.height = imageData.height;
+        const resultCtx = resultCanvas.getContext('2d');
+        if (!resultCtx) {
+            throw new Error('无法创建Canvas上下文');
+        }
+        // 根据图像特性确定分割方向和每块大小
+        const isWide = imageData.width > imageData.height;
+        const chunkSize = Math.floor((isWide ? imageData.width : imageData.height) / chunks);
+        // 创建Worker处理每个块
+        const promises = [];
+        for (let i = 0; i < chunks; i++) {
+            const chunkCanvas = document.createElement('canvas');
+            const chunkCtx = chunkCanvas.getContext('2d');
+            if (!chunkCtx)
+                continue;
+            let chunkImageData;
+            if (isWide) {
+                // 水平分割
+                const startX = i * chunkSize;
+                const width = (i === chunks - 1) ? imageData.width - startX : chunkSize;
+                chunkCanvas.width = width;
+                chunkCanvas.height = imageData.height;
+                // 复制原图像数据到分块
+                const tempCanvas = this.imageDataToCanvas(imageData);
+                chunkCtx.drawImage(tempCanvas, startX, 0, width, imageData.height, 0, 0, width, imageData.height);
+                chunkImageData = chunkCtx.getImageData(0, 0, width, imageData.height);
+            }
+            else {
+                // 垂直分割
+                const startY = i * chunkSize;
+                const height = (i === chunks - 1) ? imageData.height - startY : chunkSize;
+                chunkCanvas.width = imageData.width;
+                chunkCanvas.height = height;
+                // 复制原图像数据到分块
+                const tempCanvas = this.imageDataToCanvas(imageData);
+                chunkCtx.drawImage(tempCanvas, 0, startY, imageData.width, height, 0, 0, imageData.width, height);
+                chunkImageData = chunkCtx.getImageData(0, 0, imageData.width, height);
+            }
+            // 使用Worker处理
+            const workerCode = `
+        self.onmessage = function(e) {
+          const imageData = e.data.imageData;
+          const processingFunction = ${processingFunction.toString()};
+          const result = processingFunction(imageData);
+          self.postMessage({ result, index: e.data.index }, [result.data.buffer]);
+        }
+      `;
+            const blob = new Blob([workerCode], { type: 'application/javascript' });
+            const workerUrl = URL.createObjectURL(blob);
+            const worker = new Worker(workerUrl);
+            const promise = new Promise((resolve) => {
+                worker.onmessage = function (e) {
+                    resolve(e.data);
+                    worker.terminate();
+                    URL.revokeObjectURL(workerUrl);
+                };
+                // 传输数据
+                worker.postMessage({
+                    imageData: chunkImageData,
+                    index: i
+                }, [chunkImageData.data.buffer]);
+            });
+            promises.push(promise);
+        }
+        // 等待所有Worker完成并组合结果
+        const results = await Promise.all(promises);
+        // 按索引排序结果
+        results.sort((a, b) => a.index - b.index);
+        // 将处理后的块绘制到结果canvas
+        for (let i = 0; i < results.length; i++) {
+            const { result } = results[i];
+            const tempCanvas = this.imageDataToCanvas(result);
+            if (isWide) {
+                const startX = i * chunkSize;
+                resultCtx.drawImage(tempCanvas, startX, 0);
+            }
+            else {
+                const startY = i * chunkSize;
+                resultCtx.drawImage(tempCanvas, 0, startY);
+            }
+        }
+        return resultCtx.getImageData(0, 0, imageData.width, imageData.height);
+    }
+}
+
+/**
+ * @file 条形码扫描模块
+ * @description 提供实时条形码扫描和识别功能
+ * @module BarcodeScanner
+ */
+/**
+ * 条形码扫描器类
+ *
+ * 提供实时扫描和识别摄像头中的条形码的功能
+ * 注意：当前实现是简化版，实际项目中建议集成专门的条形码识别库如ZXing或Quagga.js
+ *
+ * @example
+ * ```typescript
+ * // 创建条形码扫描器
+ * const barcodeScanner = new BarcodeScanner({
+ *   scanInterval: 100, // 每100ms扫描一次
+ *   onScan: (result) => {
+ *     console.log('扫描到条形码:', result);
+ *   },
+ *   onError: (error) => {
+ *     console.error('扫描错误:', error);
+ *   }
+ * });
+ *
+ * // 启动扫描
+ * const videoElement = document.getElementById('video') as HTMLVideoElement;
+ * await barcodeScanner.start(videoElement);
+ *
+ * // 停止扫描
+ * barcodeScanner.stop();
+ * ```
+ */
+class BarcodeScanner {
+    /**
+     * 创建条形码扫描器实例
+     *
+     * @param {BarcodeScannerOptions} [options] - 扫描器配置选项
+     */
+    constructor(options = {}) {
+        this.options = options;
+        this.scanning = false;
+        this.scanTimer = null;
+        this.options = {
+            scanInterval: 200,
+            ...options
+        };
+        this.camera = new Camera();
+    }
+    /**
+     * 启动条形码扫描
+     *
+     * 初始化相机并开始连续扫描视频帧中的条形码
+     *
+     * @param {HTMLVideoElement} videoElement - 用于显示相机画面的video元素
+     * @returns {Promise<void>} 启动完成的Promise
+     * @throws 如果无法访问相机，将通过onError回调报告错误
+     */
+    async start(videoElement) {
+        try {
+            await this.camera.initialize(videoElement);
+            this.scanning = true;
+            this.scan();
+        }
+        catch (error) {
+            if (this.options.onError) {
+                this.options.onError(error instanceof Error ? error : new Error(String(error)));
+            }
+        }
+    }
+    /**
+     * 执行一次条形码扫描
+     *
+     * 内部方法，捕获当前视频帧并尝试识别其中的条形码
+     *
+     * @private
+     */
+    scan() {
+        if (!this.scanning)
+            return;
+        const imageData = this.camera.captureFrame();
+        if (imageData) {
+            try {
+                // 图像预处理，提高识别率
+                const enhancedImage = ImageProcessor.adjustBrightnessContrast(ImageProcessor.toGrayscale(imageData), 10, // 亮度
+                20 // 对比度
+                );
+                // 这里实际项目中可以集成第三方条形码扫描库
+                // 如 ZXing 或 QuaggaJS
+                // 简化实现，这里仅为示例
+                this.detectBarcode(enhancedImage);
+            }
+            catch (error) {
+                console.error('条形码扫描错误:', error);
+            }
+        }
+        this.scanTimer = window.setTimeout(() => this.scan(), this.options.scanInterval);
+    }
+    /**
+     * 条形码检测方法
+     *
+     * 注意：这是一个简化实现，实际需要集成专门的条形码识别库
+     *
+     * @private
+     * @param {ImageData} imageData - 要检测条形码的图像数据
+     */
+    detectBarcode(imageData) {
+        // 这里应集成条形码识别库
+        // 如 ZXing 或 QuaggaJS
+        // 简化示例，实际项目中请替换为真实实现
+        console.log('正在扫描条形码...');
+        // 模拟找到条形码
+        if (Math.random() > 0.95) {
+            const mockResult = '6901234567890'; // 模拟条形码结果
+            if (this.options.onScan) {
+                this.options.onScan(mockResult);
+            }
+        }
+    }
+    /**
+     * 停止条形码扫描
+     *
+     * 停止扫描循环并释放相机资源
+     */
+    stop() {
+        this.scanning = false;
+        if (this.scanTimer) {
+            clearTimeout(this.scanTimer);
+            this.scanTimer = null;
+        }
+        this.camera.release();
+    }
+}
+
+/**
+ * @file 二维码和条形码扫描模块
+ * @description 包含二维码和条形码扫描功能
+ * @module IDScannerQR
+ * @version 1.0.0
+ * @license MIT
+ */
+/**
+ * 扫描模块类
+ *
+ * 提供独立的二维码和条形码扫描功能
+ */
+class ScannerModule {
+    /**
+     * 构造函数
+     * @param options 配置选项
+     */
+    constructor(options = {}) {
+        this.options = options;
+        this.scanMode = null;
+        this.videoElement = null;
+        this.camera = new Camera(options.cameraOptions);
+        this.qrScanner = new QRScanner({
+            ...options.qrScannerOptions,
+            onScan: this.handleQRScan.bind(this)
+        });
+        this.barcodeScanner = new BarcodeScanner({
+            ...options.barcodeScannerOptions,
+            onScan: this.handleBarcodeScan.bind(this)
+        });
+    }
+    /**
+     * 启动二维码扫描
+     * @param videoElement HTML视频元素
+     */
+    async startQRScanner(videoElement) {
+        this.stop(); // 确保先停止可能正在运行的扫描
+        this.videoElement = videoElement;
+        this.scanMode = 'qr';
+        await this.camera.start(videoElement);
+        this.qrScanner.start(videoElement);
+    }
+    /**
+     * 启动条形码扫描
+     * @param videoElement HTML视频元素
+     */
+    async startBarcodeScanner(videoElement) {
+        this.stop(); // 确保先停止可能正在运行的扫描
+        this.videoElement = videoElement;
+        this.scanMode = 'barcode';
+        await this.camera.start(videoElement);
+        this.barcodeScanner.start(videoElement);
+    }
+    /**
+     * 停止扫描
+     */
+    stop() {
+        if (this.scanMode === 'qr') {
+            this.qrScanner.stop();
+        }
+        else if (this.scanMode === 'barcode') {
+            this.barcodeScanner.stop();
+        }
+        if (this.videoElement) {
+            this.camera.stop();
+        }
+        this.scanMode = null;
+    }
+    /**
+     * 处理二维码扫描结果
+     */
+    handleQRScan(result) {
+        if (this.options.onQRCodeScanned) {
+            this.options.onQRCodeScanned(result);
+        }
+    }
+    /**
+     * 处理条形码扫描结果
+     */
+    handleBarcodeScan(result) {
+        if (this.options.onBarcodeScanned) {
+            this.options.onBarcodeScanned(result);
+        }
+    }
+    /**
+     * 处理错误
+     */
+    handleError(error) {
+        if (this.options.onError) {
+            this.options.onError(error);
+        }
+        else {
+            console.error('ScannerModule error:', error);
+        }
+    }
+}
+
+export { BarcodeScanner, Camera, QRScanner, ScannerModule };
+//# sourceMappingURL=id-scanner-qr.esm.js.map