@xbone-3/cordova-plugin-mlkit-barcodescanner 4.0.0

package/www/BarcodeScanner.plugin.js

@@ -0,0 +1,145 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const barcodeFormat = Object.freeze({
+    Code128: 1,
+    Code39: 2,
+    Code93: 4,
+    CodaBar: 8,
+    DataMatrix: 16,
+    EAN13: 32,
+    EAN8: 64,
+    ITF: 128,
+    QRCode: 256,
+    UPCA: 512,
+    UPCE: 1024,
+    PDF417: 2048,
+    Aztec: 4096,
+});
+const barcodeType = Object.freeze({
+    CONTACT_INFO: 1,
+    EMAIL: 2,
+    ISBN: 3,
+    PHONE: 4,
+    PRODUCT: 5,
+    SMS: 6,
+    TEXT: 7,
+    URL: 8,
+    WIFI: 9,
+    GEO: 10,
+    CALENDAR_EVENT: 11,
+    DRIVER_LICENSE: 12,
+});
+
+const defaultOptions = Object.freeze({
+    barcodeFormats: {
+        Code128: true,
+        Code39: true,
+        Code93: true,
+        CodaBar: true,
+        DataMatrix: true,
+        EAN13: true,
+        EAN8: true,
+        ITF: true,
+        QRCode: true,
+        UPCA: true,
+        UPCE: true,
+        PDF417: true,
+        Aztec: true,
+    },
+    beepOnSuccess: false,
+    vibrateOnSuccess: false,
+    detectorSize: 0.6,
+    rotateCamera: false,
+    continuous: false,
+    multiple: false,
+    drawDetectionBorder: false,
+    confirmation: false,
+});
+
+function keyByValue(obj, value) {
+    const keys = Object.keys(obj);
+    const index = keys.map((key) => obj[key]).indexOf(value);
+    return keys[index] || String(value);
+}
+
+class MLKitBarcodeScanner {
+    getBarcodeFormat(format) {
+        return keyByValue(barcodeFormat, format);
+    }
+    getBarcodeType(type) {
+        return keyByValue(barcodeType, type);
+    }
+    getBarcodeFormatFlags(barcodeFormats) {
+        let barcodeFormatFlag = 0;
+        let key;
+        const formats = barcodeFormats || defaultOptions.barcodeFormats;
+        // eslint-disable-next-line no-restricted-syntax
+        for (key in formats) {
+            if (barcodeFormat.hasOwnProperty(key) &&
+                formats.hasOwnProperty(key) &&
+                formats[key]) {
+                barcodeFormatFlag += barcodeFormat[key];
+            }
+        }
+        return barcodeFormatFlag;
+    }
+    scan(userOptions, success, failure) {
+        const barcodeFormats = (userOptions === null || userOptions === void 0 ? void 0 : userOptions.barcodeFormats) || defaultOptions.barcodeFormats;
+        const config = {
+            ...defaultOptions,
+            ...userOptions,
+            barcodeFormats: this.getBarcodeFormatFlags(barcodeFormats),
+        };
+        this.sendScanRequest(config, success, failure);
+    }
+    sendScanRequest(config, successCallback, failureCallback) {
+        cordova.exec((data) => {
+            // A single scan can arrive as a flat triple [text, format, type]
+            // (iOS / legacy), while multi and continuous scans send an array of
+            // such triples. Normalise to an array either way.
+            const triples = Array.isArray(data[0])
+                ? data
+                : [data];
+            const results = triples.map(([text, format, type]) => ({
+                text,
+                format: this.getBarcodeFormat(format),
+                type: this.getBarcodeType(type),
+            }));
+            successCallback(config.multiple ? results : results[0]);
+        }, (err) => {
+            // Plugin errors arrive as an array ([code, ...]), but Cordova
+            // framework errors (e.g. "Class not found") arrive as a plain
+            // string. Normalise to the error code/message either way.
+            const code = Array.isArray(err) ? err[0] : err;
+            switch (code) {
+                case null:
+                case undefined:
+                case 'USER_CANCELLED':
+                    failureCallback({
+                        cancelled: true,
+                        message: 'The scan was cancelled.',
+                    });
+                    break;
+                case 'SCANNER_OPEN':
+                    failureCallback({
+                        cancelled: false,
+                        message: 'Scanner already open.',
+                    });
+                    break;
+                default:
+                    failureCallback({
+                        cancelled: false,
+                        message: code || 'Unknown Error',
+                    });
+                    break;
+            }
+        }, 'cordova-plugin-mlkit-barcodescanner', 'startScan', [config]);
+    }
+}
+const barcodeScanner = new MLKitBarcodeScanner();
+module.exports = barcodeScanner;
+
+exports.MLKitBarcodeScanner = MLKitBarcodeScanner;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"BarcodeScanner.plugin.js","sources":["../src-typescript/Detector.ts","../src-typescript/Options.ts","../src-typescript/util/Object.ts","../src-typescript/BarcodeScanner.plugin.ts"],"sourcesContent":["export const barcodeFormat = Object.freeze({\r\n  Code128: 1,\r\n  Code39: 2,\r\n  Code93: 4,\r\n  CodaBar: 8,\r\n  DataMatrix: 16,\r\n  EAN13: 32,\r\n  EAN8: 64,\r\n  ITF: 128,\r\n  QRCode: 256,\r\n  UPCA: 512,\r\n  UPCE: 1024,\r\n  PDF417: 2048,\r\n  Aztec: 4096,\r\n});\r\n\r\nexport const barcodeType = Object.freeze({\r\n  CONTACT_INFO: 1,\r\n  EMAIL: 2,\r\n  ISBN: 3,\r\n  PHONE: 4,\r\n  PRODUCT: 5,\r\n  SMS: 6,\r\n  TEXT: 7,\r\n  URL: 8,\r\n  WIFI: 9,\r\n  GEO: 10,\r\n  CALENDAR_EVENT: 11,\r\n  DRIVER_LICENSE: 12,\r\n});\r\n","import { IOptions } from './Interface';\r\n\r\nexport const defaultOptions: Required<IOptions> = Object.freeze({\r\n  barcodeFormats: {\r\n    Code128: true,\r\n    Code39: true,\r\n    Code93: true,\r\n    CodaBar: true,\r\n    DataMatrix: true,\r\n    EAN13: true,\r\n    EAN8: true,\r\n    ITF: true,\r\n    QRCode: true,\r\n    UPCA: true,\r\n    UPCE: true,\r\n    PDF417: true,\r\n    Aztec: true,\r\n  },\r\n  beepOnSuccess: false,\r\n  vibrateOnSuccess: false,\r\n  detectorSize: 0.6,\r\n  rotateCamera: false,\r\n  continuous: false,\r\n  multiple: false,\r\n  drawDetectionBorder: false,\r\n  confirmation: false,\r\n});\r\n","export function keyByValue<TObject>(\r\n  obj: { [s: string]: TObject },\r\n  value: TObject,\r\n): string {\r\n  const keys = Object.keys(obj);\r\n  const index = keys.map((key) => obj[key]).indexOf(value);\r\n  return keys[index] || String(value);\r\n}\r\n","import { barcodeFormat, barcodeType } from './Detector';\r\nimport {\r\n  IBarcodeFormats,\r\n  IConfig,\r\n  IError,\r\n  IOptions,\r\n  IResult,\r\n} from './Interface';\r\nimport { defaultOptions } from './Options';\r\nimport { keyByValue } from './util/Object';\r\n\r\nexport class MLKitBarcodeScanner {\r\n  private getBarcodeFormat(format: number): string {\r\n    return keyByValue(barcodeFormat, format);\r\n  }\r\n\r\n  private getBarcodeType(type: number): string {\r\n    return keyByValue(barcodeType, type);\r\n  }\r\n\r\n  private getBarcodeFormatFlags(barcodeFormats?: IBarcodeFormats): number {\r\n    let barcodeFormatFlag = 0;\r\n    let key: keyof typeof barcodeFormat;\r\n    const formats = barcodeFormats || defaultOptions.barcodeFormats;\r\n\r\n    // eslint-disable-next-line no-restricted-syntax\r\n    for (key in formats) {\r\n      if (\r\n        barcodeFormat.hasOwnProperty(key) &&\r\n        formats.hasOwnProperty(key) &&\r\n        formats[key]\r\n      ) {\r\n        barcodeFormatFlag += barcodeFormat[key];\r\n      }\r\n    }\r\n    return barcodeFormatFlag;\r\n  }\r\n\r\n  scan(\r\n    userOptions: IOptions,\r\n    success: (result: IResult | IResult[]) => unknown,\r\n    failure: (error: IError) => unknown,\r\n  ): void {\r\n    const barcodeFormats =\r\n      userOptions?.barcodeFormats || defaultOptions.barcodeFormats;\r\n    const config: IConfig = {\r\n      ...defaultOptions,\r\n      ...userOptions,\r\n      barcodeFormats: this.getBarcodeFormatFlags(barcodeFormats),\r\n    };\r\n\r\n    this.sendScanRequest(config, success, failure);\r\n  }\r\n\r\n  private sendScanRequest(\r\n    config: IConfig,\r\n    successCallback: (result: IResult | IResult[]) => unknown,\r\n    failureCallback: (error: IError) => unknown,\r\n  ): void {\r\n    type Triple = [string, number, number];\r\n    cordova.exec(\r\n      (data: Triple | Triple[]) => {\r\n        // A single scan can arrive as a flat triple [text, format, type]\r\n        // (iOS / legacy), while multi and continuous scans send an array of\r\n        // such triples. Normalise to an array either way.\r\n        const triples: Triple[] = Array.isArray(data[0])\r\n          ? (data as Triple[])\r\n          : [data as Triple];\r\n\r\n        const results: IResult[] = triples.map(([text, format, type]) => ({\r\n          text,\r\n          format: this.getBarcodeFormat(format),\r\n          type: this.getBarcodeType(type),\r\n        }));\r\n\r\n        successCallback(config.multiple ? results : results[0]);\r\n      },\r\n      (err: string | (string | null)[] | null) => {\r\n        // Plugin errors arrive as an array ([code, ...]), but Cordova\r\n        // framework errors (e.g. \"Class not found\") arrive as a plain\r\n        // string. Normalise to the error code/message either way.\r\n        const code = Array.isArray(err) ? err[0] : err;\r\n\r\n        switch (code) {\r\n          case null:\r\n          case undefined:\r\n          case 'USER_CANCELLED':\r\n            failureCallback({\r\n              cancelled: true,\r\n              message: 'The scan was cancelled.',\r\n            });\r\n            break;\r\n          case 'SCANNER_OPEN':\r\n            failureCallback({\r\n              cancelled: false,\r\n              message: 'Scanner already open.',\r\n            });\r\n            break;\r\n          default:\r\n            failureCallback({\r\n              cancelled: false,\r\n              message: code || 'Unknown Error',\r\n            });\r\n            break;\r\n        }\r\n      },\r\n      'cordova-plugin-mlkit-barcodescanner',\r\n      'startScan',\r\n      [config],\r\n    );\r\n  }\r\n}\r\n\r\nconst barcodeScanner = new MLKitBarcodeScanner();\r\nmodule.exports = barcodeScanner;\r\n"],"names":[],"mappings":"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"}

package/www/Detector.d.ts

@@ -0,0 +1,29 @@
+export declare const barcodeFormat: Readonly<{
+    Code128: number;
+    Code39: number;
+    Code93: number;
+    CodaBar: number;
+    DataMatrix: number;
+    EAN13: number;
+    EAN8: number;
+    ITF: number;
+    QRCode: number;
+    UPCA: number;
+    UPCE: number;
+    PDF417: number;
+    Aztec: number;
+}>;
+export declare const barcodeType: Readonly<{
+    CONTACT_INFO: number;
+    EMAIL: number;
+    ISBN: number;
+    PHONE: number;
+    PRODUCT: number;
+    SMS: number;
+    TEXT: number;
+    URL: number;
+    WIFI: number;
+    GEO: number;
+    CALENDAR_EVENT: number;
+    DRIVER_LICENSE: number;
+}>;

package/www/Interface.d.ts

@@ -0,0 +1,65 @@
+export interface IBarcodeFormats {
+    Aztec: boolean;
+    CodaBar: boolean;
+    Code39: boolean;
+    Code93: boolean;
+    Code128: boolean;
+    DataMatrix: boolean;
+    EAN8: boolean;
+    EAN13: boolean;
+    ITF: boolean;
+    PDF417: boolean;
+    QRCode: boolean;
+    UPCA: boolean;
+    UPCE: boolean;
+}
+export interface IOptions {
+    barcodeFormats?: IBarcodeFormats;
+    beepOnSuccess?: boolean;
+    vibrateOnSuccess?: boolean;
+    detectorSize?: number;
+    rotateCamera?: boolean;
+    /**
+     * Keep the camera open and stream every newly detected barcode back to the
+     * success callback (which may be invoked many times). The scanner closes
+     * when the user presses back, surfacing a cancelled error. Default: false.
+     */
+    continuous?: boolean;
+    /**
+     * Detect every barcode visible in a frame instead of just the first one.
+     * When enabled the success callback receives an array of results. Default:
+     * false.
+     */
+    multiple?: boolean;
+    /**
+     * Draw a border around each barcode as it is detected in the camera
+     * preview, tracing the code's corner points. Default: false.
+     */
+    drawDetectionBorder?: boolean;
+    /**
+     * Require the user to confirm a detected barcode before it is returned. The
+     * preview freezes on the detected frame with a Confirm/Retry prompt. Ignored
+     * in continuous mode. Default: false.
+     */
+    confirmation?: boolean;
+}
+export interface IConfig {
+    barcodeFormats: number;
+    beepOnSuccess: boolean;
+    vibrateOnSuccess: boolean;
+    detectorSize: number;
+    rotateCamera: boolean;
+    continuous: boolean;
+    multiple: boolean;
+    drawDetectionBorder: boolean;
+    confirmation: boolean;
+}
+export interface IResult {
+    text: string;
+    format: string;
+    type: string;
+}
+export interface IError {
+    cancelled: boolean;
+    message: string;
+}

package/www/Options.d.ts

@@ -0,0 +1,2 @@
+import { IOptions } from './Interface';
+export declare const defaultOptions: Required<IOptions>;

package/www/util/Object.d.ts

@@ -0,0 +1,3 @@
+export declare function keyByValue<TObject>(obj: {
+    [s: string]: TObject;
+}, value: TObject): string;