Fix #8: reject detection promise in case of error, assert argument type

Author: undecaf

README.md

@@ -113,7 +113,10 @@ const detector = new BarcodeDetectorPolyfill({
 const barcodes = await detector.detect(source)
 ```
 
-`source` may be any object of which an [`ImageBitmap`](https://developer.mozilla.org/en-US/docs/Web/API/ImageBitmap) can be obtained:
+`source` must be an object of which an [`ImageBitmap`](https://developer.mozilla.org/en-US/docs/Web/API/ImageBitmap)
+can be obtained, or else a 
+[`TypeError`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypeError)
+will be thrown:
 
 + an `<img>` element ([`HTMLImageElement`](https://developer.mozilla.org/en-US/docs/Web/API/HTMLImageElement))
 + a `<video>` element ([`HTMLVideoElement`](https://developer.mozilla.org/en-US/docs/Web/API/HTMLVideoElement))
@@ -125,6 +128,8 @@ const barcodes = await detector.detect(source)
 + a [`Blob`](https://developer.mozilla.org/en-US/docs/Web/API/Blob) or a 
   [`File`](https://developer.mozilla.org/en-US/docs/Web/API/File) with a content `type` of `image/*`
 
+In addition, any object with a zero `width` or `height` property will be tolerated.
+
 The detector processes the `source` in natural size, making detection results independent of the size rendered
 by the browser.
 
@@ -145,6 +150,10 @@ Additional properties provided only by `BarcodeDetectorPolyfill`:
 + `quality`: a positive integer indicating the barcode quality as seen by the detector,
   specific to each `format`
 
+If an error occurs during barcode detection then the `detect()` method returns a rejected
+[`Promise`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise)
+containing the error.
+
 
 ### Typescript support
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@undecaf/barcode-detector-polyfill",
-  "version": "0.9.13",
+  "version": "0.9.14",
   "description": "A WebAssembly polyfill for the Barcode Detection API",
   "keywords": [
     "polyfill",

src/BarcodeDetectorPolyfill.ts

@@ -57,41 +57,54 @@ export class BarcodeDetectorPolyfill {
      * Scans an image for barcodes and returns a {@link Promise} for the result.
      *
      * @param {ImageBitmapSource} source the image to be scanned
-     * @returns {Promise<Array<DetectedBarcode>>} the scan result as described for {@link BarcodeDetector}
+     * @returns {Promise<Array<DetectedBarcode>>} the scan result as described for {@link BarcodeDetector},
+     *  or a rejected {@link Promise} containing the error
+     * @throws {TypeError} if the argument is not an {@link ImageBitmapSource}
      */
     // TODO Enable cache for video source, disable for others unless overridden in zbarConfig
     detect(source: ImageBitmapSource): Promise<Array<DetectedBarcode>> {
+        // Assert the argument type
+        if (!BarcodeDetectorPolyfill.isImageBitmapSource(source)) {
+            throw new TypeError('BarcodeDetector.detect() argument is not an ImageBitmapSource')
+        }
+
         // Return an empty array immediately if the source is an object with any zero dimension,
         // see https://wicg.github.io/shape-detection-api/#image-sources-for-detection
         const intrinsic = BarcodeDetectorPolyfill.intrinsicDimensions(source)
         if ((intrinsic.width === 0) || (intrinsic.height === 0)) {
             return Promise.resolve([])
 
         } else {
-            return Promise
-                .all([
-                    this.toImageData(source),
-                    this.getScanner()
-                ])
-
-                .then(fulfilled => {
-                    const
-                        imageData: ImageData = fulfilled[0],
-                        scanner: ZBarScanner = fulfilled[1];
-
-                    // Configure the image cache if so requested
-                    if (typeof this.zbarConfig.enableCache !== 'undefined') {
-                        scanner.enableCache(this.zbarConfig.enableCache)
-                    }
-
-                    return scanRGBABuffer(imageData.data, imageData.width, imageData.height, scanner)
-                })
-
-                .then(symbols => {
-                    return symbols.map(symbol =>
-                        this.toBarcodeDetectorResult(symbol)
-                    )
-                })
+            try {
+                return Promise
+                    .all([
+                        this.toImageData(source),
+                        this.getScanner()
+                    ])
+
+                    .then(fulfilled => {
+                        const
+                            imageData: ImageData = fulfilled[0],
+                            scanner: ZBarScanner = fulfilled[1];
+
+                        // Configure the image cache if so requested
+                        if (typeof this.zbarConfig.enableCache !== 'undefined') {
+                            scanner.enableCache(this.zbarConfig.enableCache)
+                        }
+
+                        return scanRGBABuffer(imageData.data, imageData.width, imageData.height, scanner)
+                    })
+
+                    .then(symbols => {
+                        return symbols.map(symbol =>
+                            this.toBarcodeDetectorResult(symbol)
+                        )
+                    })
+
+            } catch (error) {
+                // #8: return a rejected Promise if an exception occurred
+                return Promise.reject(error)
+            }
         }
 
     }
@@ -205,6 +218,24 @@ export class BarcodeDetectorPolyfill {
     }
 
 
+    /**
+     * Type guard for {@link external:ImageBitmapSource} and any
+     * object having zero width or height.
+     */
+    private static isImageBitmapSource(source: any): source is ImageBitmapSource {
+        return (source instanceof HTMLImageElement)
+            || (source instanceof HTMLVideoElement)
+            || (source instanceof HTMLCanvasElement)
+            || (source instanceof Blob)
+            || (source instanceof ImageData)
+            || (source instanceof CanvasRenderingContext2D)
+            || (source instanceof ImageBitmap)
+            // Note the (lenient) equality operator
+            || (source && source.width == 0)
+            || (source && source.height == 0)
+    }
+
+
     /**
      * Returns the intrinsic (as opposed to the rendered)
      * dimensions of an {@link external:ImageBitmapSource}.

tests/unit/20-detection.spec.js

@@ -322,6 +322,39 @@ describe('BarcodeDetectorPolyfill detection', () => {
 
                 expect(barcodes).to.be.an('array').that.has.lengthOf(0)
             })
+        });
+
+
+    [undefined, null, '', 0, {}, { width: 1 }]
+        .forEach(source => {
+            it(`throws a TypeError if the detect() argument is ${source}`, async () => {
+                const detector = new BarcodeDetectorPolyfill({formats: tests[0].format})
+                try {
+                    detector.detect(source)
+
+                } catch (error) {
+                    expect(error instanceof TypeError).to.equal(true, `Exception is not a TypeError but ${error}`)
+                    return
+                }
+
+                expect(false).to.equal(true, 'No exception was thrown')
+            })
+        });
+
+
+    [
+        document.createElement('img'),
+        document.createElement('video'),
+        document.createElement('canvas'),
+        new Blob(),
+    ]
+        .forEach(source => {
+            it(`returns a rejected Promise for an invalid ${source}`, () => {
+                const detector = new BarcodeDetectorPolyfill({formats: tests[0].format})
+                detector.detect(source)
+                    .then((result) => expect(false).to.equal(true, `Promise not rejected but resolved with ${result}`))
+                    .catch(() => {})
+            })
         })
 
 })