barsa-develop-components 0.0.2

package/esm2020/lib/barcode.service.mjs

@@ -0,0 +1,330 @@
+import { DecodeHintType, BarcodeFormat } from '@zxing/library';
+import { ChecksumException, FormatException, NotFoundException } from '@zxing/library';
+import { BrowserCodeReader, BrowserMultiFormatReader } from '@zxing/browser';
+import { BehaviorSubject, Subject } from 'rxjs';
+import { filter, map, shareReplay } from 'rxjs/operators';
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "barsa-novin-ray-core";
+/**
+ * Based on zxing-typescript BrowserCodeReader
+ */
+export class BrowserMultiFormatContinuousReader extends BrowserMultiFormatReader {
+    /**
+     * Returns the code reader scanner controls.
+     */
+    getScannerControls() {
+        if (!this.scannerControls) {
+            throw new Error('No scanning is running at the time.');
+        }
+        return this.scannerControls;
+    }
+    /**
+     * Starts the decoding from the current or a new video element.
+     *
+     * @param deviceId The device's to be used Id
+     * @param previewEl A new video element
+     */
+    async scanFromDeviceObservable(deviceId, previewEl) {
+        const scan$ = new BehaviorSubject({});
+        let ctrls;
+        try {
+            ctrls = await this.decodeFromVideoDevice(deviceId, previewEl, (result, error) => {
+                if (!error) {
+                    scan$.next({ result });
+                    return;
+                }
+                console.error(error);
+                const errorName = error.name;
+                // stream cannot stop on fails.
+                if (
+                // scan Failure - found nothing, no error
+                errorName === NotFoundException.name ||
+                    // scan Error - found the QR but got error on decoding
+                    errorName === ChecksumException.name ||
+                    errorName === FormatException.name ||
+                    error.message.includes('No MultiFormat Readers were able to detect the code.')) {
+                    scan$.next({ error });
+                    return;
+                }
+                // probably fatal error
+                scan$.error(error);
+                this.scannerControls?.stop();
+                this.scannerControls = undefined;
+                return;
+            });
+            this.scannerControls = {
+                ...ctrls,
+                stop() {
+                    ctrls.stop();
+                    scan$.complete();
+                }
+            };
+        }
+        catch (e) {
+            scan$.error(e);
+            this.scannerControls?.stop();
+            this.scannerControls = undefined;
+        }
+        return scan$.asObservable();
+    }
+}
+export class UserMediaBaseService {
+    /**
+     *
+     */
+    constructor(_logService) {
+        this._logService = _logService;
+        this.hasNavigator = false;
+        this.isMediaDevicesSupported = false;
+        this._camerasSource = new BehaviorSubject([]);
+        this.cameras$ = this._camerasSource
+            .asObservable()
+            .pipe(shareReplay(1))
+            .pipe(filter((items) => items && items.length > 0));
+        this._permissionResponse = new Subject();
+        this.permissionResponse$ = this._permissionResponse.asObservable();
+        this._hasDevicesSource = new BehaviorSubject(false);
+        this.hasDevices$ = this._hasDevicesSource.asObservable().pipe(shareReplay(1));
+        this._permissionSource = new BehaviorSubject(false);
+        this.permission$ = this._permissionSource.asObservable().pipe();
+        this._camerasNotFoundSource = new Subject();
+        this.camerasNotFound$ = this._camerasNotFoundSource.asObservable().pipe(shareReplay(1));
+        this.hasNavigator = typeof navigator !== 'undefined';
+        this.isMediaDevicesSupported = this.hasNavigator && !!navigator.mediaDevices;
+    }
+    async updateVideoInputDevices() {
+        // permissions aren't needed to get devices, but to access them and their info
+        const devices = (await BrowserCodeReader.listVideoInputDevices()) || [];
+        const hasDevices = devices && devices.length > 0;
+        // stores discovered devices and updates information
+        this._hasDevicesSource.next(hasDevices);
+        this._camerasSource.next([...devices]);
+        if (!hasDevices) {
+            const err = {
+                code: DOMException.NOT_FOUND_ERR,
+                message: 'Device not found.'
+            };
+            this._camerasNotFoundSource.next(err);
+        }
+        return devices;
+    }
+    /**
+     * Gets and registers all cammeras.
+     */
+    async askForPermission() {
+        if (!this.hasNavigator) {
+            this._logService.error('user media', `Can't ask permission, navigator is not present.`);
+            this._setPermission(false);
+        }
+        if (!this.isMediaDevicesSupported) {
+            this._logService.error('user media', `Can't get user media, this is not supported.`);
+            this._setPermission(false);
+        }
+        let stream;
+        let permission = false;
+        try {
+            // Will try to ask for permission
+            stream = await this._getAnyVideoDevice();
+            permission = !!stream;
+        }
+        catch (err) {
+            this._handlePermissionException(err);
+        }
+        finally {
+            this.terminateStream(stream);
+        }
+        this._setPermission(permission);
+        return permission;
+    }
+    terminateStream(stream) {
+        if (stream) {
+            stream.getTracks().forEach((t) => t.stop());
+        }
+        stream = undefined;
+    }
+    _setPermission(permission) {
+        this._permissionSource.next(permission);
+    }
+    _getAnyVideoDevice() {
+        return navigator.mediaDevices.getUserMedia({ video: true });
+    }
+    _handlePermissionException(err) {
+        console.error('user media', 'Error when asking for permission.', err);
+        let permission = false;
+        switch (err.name) {
+            // usually caused by not secure origins
+            case 'NotSupportedError':
+                this._logService.warn('user media', err.message);
+                // could not claim
+                permission = false;
+                // can't check devices
+                this._hasDevicesSource.next(false);
+                break;
+            // user denied permission
+            case 'NotAllowedError':
+                this._logService.warn('user media', err.message);
+                // claimed and denied permission
+                permission = false;
+                // this means that input devices exists
+                this._hasDevicesSource.next(true);
+                break;
+            // the device has no attached input devices
+            case 'NotFoundError':
+                this._logService.warn('user media', err.message);
+                // no permissions claimed
+                permission = false;
+                // because there was no devices
+                this._hasDevicesSource.next(false);
+                // tells the listener about the error
+                this._camerasNotFoundSource.next(err);
+                break;
+            case 'NotReadableError':
+                this._logService.warn('user media', `Couldn't read the device(s)'s stream, it's probably in use by another app.`);
+                // no permissions claimed
+                permission = false;
+                // there are devices, which I couldn't use
+                this._hasDevicesSource.next(false);
+                // tells the listener about the error
+                this._camerasNotFoundSource.next(err);
+                break;
+            default:
+                this._logService.warn('user media', 'I was not able to define if I have permissions for camera or not.', err);
+                // unknown
+                permission = false;
+                // this.hasDevices.next(undefined;
+                break;
+        }
+        this._setPermission(permission);
+        // tells the listener about the error
+        this._permissionResponse.next(err);
+        return permission;
+    }
+}
+UserMediaBaseService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: UserMediaBaseService, deps: [{ token: i1.LogService }], target: i0.ɵɵFactoryTarget.Injectable });
+UserMediaBaseService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: UserMediaBaseService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: UserMediaBaseService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.LogService }]; } });
+export class WebBarcodeService {
+    constructor(userMediaService) {
+        this.userMediaService = userMediaService;
+        this._device = undefined;
+        this._codeReader = undefined;
+        this._hints = new Map();
+        this._scanErrorSource = new Subject();
+        this._scanFailureSource = new Subject();
+        this._scanCompleteSource = new Subject();
+        this._scanSuccessSource = new Subject();
+        this._options = {
+            delayBetweenScanAttempts: 50,
+            delayBetweenScanSuccess: 500
+        };
+        this.scanError$ = this._scanErrorSource.asObservable();
+        this.scanFailure$ = this._scanFailureSource.asObservable();
+        this.scanComplete$ = this._scanCompleteSource.asObservable();
+        this.scanSuccess$ = this._scanSuccessSource.asObservable().pipe(map((c) => c.getText()));
+    }
+    startScan(device, videoEl, options = this._options) {
+        // instantly stops the scan before changing devices
+        this.scanStop();
+        // correctly sets the new (or none) device
+        this._device = device || undefined;
+        this._videoEl = videoEl;
+        this._options = options;
+        if (!this._device) {
+            // cleans the video because user removed the device
+            BrowserCodeReader.cleanVideoSource(videoEl);
+        }
+        if (this._scanSubscription) {
+            throw new Error('There is already a scan proccess running.');
+        }
+        if (!this._device) {
+            throw new Error('No device defined, cannot start scan, please define a device.');
+        }
+        // if enabled, starts scanning
+        if (device) {
+            this.scanFromDevice(device.deviceId);
+        }
+    }
+    setFormat(input) {
+        if (typeof input === 'string') {
+            throw new Error('Invalid formats, make sure the [formats] input is a binding.');
+        }
+        // formats may be set from html template as BarcodeFormat or string array
+        const formats = input.map((f) => this.getBarcodeFormatOrFail(f));
+        const hints = this._hints;
+        // updates the hints
+        hints.set(DecodeHintType.POSSIBLE_FORMATS, formats);
+        // handles updating the codeReader
+        this._hints = hints;
+    }
+    scanStop() {
+        if (this._scanSubscription) {
+            this._codeReader?.getScannerControls().stop();
+            this._scanSubscription?.unsubscribe();
+            this._scanSubscription = undefined;
+        }
+        // this.torchCompatible.next(false);
+    }
+    destroy() {
+        // @note apenas necessario por enquanto causa da Torch
+        this.scanStop();
+        this._codeReader = undefined;
+        this._device = undefined;
+    }
+    getBarcodeFormatOrFail(format) {
+        return typeof format === 'string' ? BarcodeFormat[format.trim().toUpperCase()] : format;
+    }
+    async scanFromDevice(deviceId) {
+        const videoElement = this._videoEl;
+        const codeReader = this.getCodeReader();
+        const scanStream = await codeReader.scanFromDeviceObservable(deviceId, videoElement);
+        if (!scanStream) {
+            throw new Error('Undefined decoding stream, aborting.');
+        }
+        const next = (x) => this._onDecodeResult(x.result, x.error);
+        const error = (err) => this._onDecodeError(err);
+        const complete = () => { };
+        this._scanSubscription = scanStream.subscribe(next, error, complete);
+        if (this._scanSubscription.closed) {
+            return;
+        }
+        // const controls = codeReader.getScannerControls();
+        // const hasTorchControl = typeof controls.switchTorch !== 'undefined';
+        // this.torchCompatible.next(hasTorchControl);
+    }
+    /**
+     * Handles decode errors.
+     */
+    _onDecodeError(err) {
+        this._scanErrorSource.next(err);
+        // this.reset();
+    }
+    /**
+     * Handles decode results.
+     */
+    _onDecodeResult(result, error) {
+        if (result) {
+            this._scanSuccessSource.next(result);
+        }
+        else {
+            this._scanFailureSource.next(error);
+        }
+        if (result) {
+            this._scanCompleteSource.next(result);
+        }
+    }
+    getCodeReader() {
+        if (!this._codeReader) {
+            this._codeReader = new BrowserMultiFormatContinuousReader(this._hints, this._options);
+        }
+        return this._codeReader;
+    }
+}
+WebBarcodeService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: WebBarcodeService, deps: [{ token: UserMediaBaseService }], target: i0.ɵɵFactoryTarget.Injectable });
+WebBarcodeService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: WebBarcodeService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: WebBarcodeService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: UserMediaBaseService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"barcode.service.js","sourceRoot":"","sources":["../../../../projects/barsa-develop-components/src/lib/barcode.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Result, Exception, DecodeHintType, BarcodeFormat } from '@zxing/library';\r\nimport { ChecksumException, FormatException, NotFoundException } from '@zxing/library';\r\nimport { BrowserCodeReader, BrowserMultiFormatReader, IScannerControls } from '@zxing/browser';\r\nimport { BehaviorSubject, Observable, Subject } from 'rxjs';\r\nimport { LogService } from 'barsa-novin-ray-core';\r\nimport { filter, map, shareReplay } from 'rxjs/operators';\r\nimport { Injectable } from '@angular/core';\r\n\r\nexport interface ResultAndError {\r\n    result?: Result;\r\n    error?: Exception;\r\n}\r\n\r\n/**\r\n * Based on zxing-typescript BrowserCodeReader\r\n */\r\nexport class BrowserMultiFormatContinuousReader extends BrowserMultiFormatReader {\r\n    /**\r\n     * Allows to call scanner controls API while scanning.\r\n     * Will be undefined if no scanning is runnig.\r\n     */\r\n    protected scannerControls: IScannerControls | undefined;\r\n\r\n    /**\r\n     * Returns the code reader scanner controls.\r\n     */\r\n    public getScannerControls(): IScannerControls {\r\n        if (!this.scannerControls) {\r\n            throw new Error('No scanning is running at the time.');\r\n        }\r\n        return this.scannerControls;\r\n    }\r\n\r\n    /**\r\n     * Starts the decoding from the current or a new video element.\r\n     *\r\n     * @param deviceId The device's to be used Id\r\n     * @param previewEl A new video element\r\n     */\r\n    public async scanFromDeviceObservable(\r\n        deviceId?: string,\r\n        previewEl?: HTMLVideoElement\r\n    ): Promise<Observable<ResultAndError>> {\r\n        const scan$ = new BehaviorSubject<ResultAndError>({});\r\n        let ctrls;\r\n\r\n        try {\r\n            ctrls = await this.decodeFromVideoDevice(deviceId, previewEl, (result, error) => {\r\n                if (!error) {\r\n                    scan$.next({ result });\r\n                    return;\r\n                }\r\n                console.error(error);\r\n                const errorName = error.name;\r\n\r\n                // stream cannot stop on fails.\r\n                if (\r\n                    // scan Failure - found nothing, no error\r\n                    errorName === NotFoundException.name ||\r\n                    // scan Error - found the QR but got error on decoding\r\n                    errorName === ChecksumException.name ||\r\n                    errorName === FormatException.name ||\r\n                    error.message.includes('No MultiFormat Readers were able to detect the code.')\r\n                ) {\r\n                    scan$.next({ error });\r\n                    return;\r\n                }\r\n\r\n                // probably fatal error\r\n                scan$.error(error);\r\n                this.scannerControls?.stop();\r\n                this.scannerControls = undefined;\r\n                return;\r\n            });\r\n\r\n            this.scannerControls = {\r\n                ...ctrls,\r\n                stop(): void {\r\n                    ctrls.stop();\r\n                    scan$.complete();\r\n                }\r\n            };\r\n        } catch (e) {\r\n            scan$.error(e);\r\n            this.scannerControls?.stop();\r\n            this.scannerControls = undefined;\r\n        }\r\n\r\n        return scan$.asObservable();\r\n    }\r\n}\r\n@Injectable()\r\nexport class UserMediaBaseService {\r\n    hasNavigator = false;\r\n    isMediaDevicesSupported = false;\r\n\r\n    _camerasSource = new BehaviorSubject<MediaDeviceInfo[]>([]);\r\n    cameras$ = this._camerasSource\r\n        .asObservable()\r\n        .pipe(shareReplay(1))\r\n        .pipe(filter((items) => items && items.length > 0));\r\n\r\n    _permissionResponse = new Subject<DOMException>();\r\n    permissionResponse$ = this._permissionResponse.asObservable();\r\n\r\n    _hasDevicesSource = new BehaviorSubject<boolean>(false);\r\n    hasDevices$ = this._hasDevicesSource.asObservable().pipe(shareReplay(1));\r\n\r\n    _permissionSource = new BehaviorSubject<boolean>(false);\r\n    permission$ = this._permissionSource.asObservable().pipe();\r\n\r\n    _camerasNotFoundSource = new Subject<DOMException>();\r\n    camerasNotFound$ = this._camerasNotFoundSource.asObservable().pipe(shareReplay(1));\r\n\r\n    /**\r\n     *\r\n     */\r\n    constructor(private _logService: LogService) {\r\n        this.hasNavigator = typeof navigator !== 'undefined';\r\n        this.isMediaDevicesSupported = this.hasNavigator && !!navigator.mediaDevices;\r\n    }\r\n\r\n    async updateVideoInputDevices(): Promise<MediaDeviceInfo[]> {\r\n        // permissions aren't needed to get devices, but to access them and their info\r\n        const devices = (await BrowserCodeReader.listVideoInputDevices()) || [];\r\n        const hasDevices = devices && devices.length > 0;\r\n\r\n        // stores discovered devices and updates information\r\n        this._hasDevicesSource.next(hasDevices);\r\n        this._camerasSource.next([...devices]);\r\n\r\n        if (!hasDevices) {\r\n            const err = {\r\n                code: DOMException.NOT_FOUND_ERR,\r\n                message: 'Device not found.'\r\n            };\r\n            this._camerasNotFoundSource.next(err as DOMException);\r\n        }\r\n\r\n        return devices;\r\n    }\r\n\r\n    /**\r\n     * Gets and registers all cammeras.\r\n     */\r\n    async askForPermission(): Promise<boolean> {\r\n        if (!this.hasNavigator) {\r\n            this._logService.error('user media', `Can't ask permission, navigator is not present.`);\r\n            this._setPermission(false);\r\n        }\r\n\r\n        if (!this.isMediaDevicesSupported) {\r\n            this._logService.error('user media', `Can't get user media, this is not supported.`);\r\n            this._setPermission(false);\r\n        }\r\n\r\n        let stream: MediaStream | undefined;\r\n        let permission = false;\r\n\r\n        try {\r\n            // Will try to ask for permission\r\n            stream = await this._getAnyVideoDevice();\r\n            permission = !!stream;\r\n        } catch (err) {\r\n            this._handlePermissionException(err as DOMException);\r\n        } finally {\r\n            this.terminateStream(stream);\r\n        }\r\n\r\n        this._setPermission(permission);\r\n        return permission;\r\n    }\r\n    protected terminateStream(stream: MediaStream | undefined): void {\r\n        if (stream) {\r\n            stream.getTracks().forEach((t) => t.stop());\r\n        }\r\n\r\n        stream = undefined;\r\n    }\r\n    protected _setPermission(permission: boolean): void {\r\n        this._permissionSource.next(permission);\r\n    }\r\n    protected _getAnyVideoDevice(): Promise<MediaStream> {\r\n        return navigator.mediaDevices.getUserMedia({ video: true });\r\n    }\r\n    protected _handlePermissionException(err: DOMException): boolean {\r\n        console.error('user media', 'Error when asking for permission.', err);\r\n        let permission = false;\r\n\r\n        switch (err.name) {\r\n            // usually caused by not secure origins\r\n            case 'NotSupportedError':\r\n                this._logService.warn('user media', err.message);\r\n                // could not claim\r\n                permission = false;\r\n                // can't check devices\r\n                this._hasDevicesSource.next(false);\r\n                break;\r\n\r\n            // user denied permission\r\n            case 'NotAllowedError':\r\n                this._logService.warn('user media', err.message);\r\n                // claimed and denied permission\r\n                permission = false;\r\n                // this means that input devices exists\r\n                this._hasDevicesSource.next(true);\r\n                break;\r\n\r\n            // the device has no attached input devices\r\n            case 'NotFoundError':\r\n                this._logService.warn('user media', err.message);\r\n                // no permissions claimed\r\n                permission = false;\r\n                // because there was no devices\r\n                this._hasDevicesSource.next(false);\r\n                // tells the listener about the error\r\n                this._camerasNotFoundSource.next(err);\r\n                break;\r\n\r\n            case 'NotReadableError':\r\n                this._logService.warn(\r\n                    'user media',\r\n                    `Couldn't read the device(s)'s stream, it's probably in use by another app.`\r\n                );\r\n                // no permissions claimed\r\n                permission = false;\r\n                // there are devices, which I couldn't use\r\n                this._hasDevicesSource.next(false);\r\n                // tells the listener about the error\r\n                this._camerasNotFoundSource.next(err);\r\n                break;\r\n\r\n            default:\r\n                this._logService.warn(\r\n                    'user media',\r\n                    'I was not able to define if I have permissions for camera or not.',\r\n                    err\r\n                );\r\n                // unknown\r\n                permission = false;\r\n                // this.hasDevices.next(undefined;\r\n                break;\r\n        }\r\n\r\n        this._setPermission(permission);\r\n\r\n        // tells the listener about the error\r\n        this._permissionResponse.next(err);\r\n\r\n        return permission;\r\n    }\r\n}\r\n@Injectable()\r\nexport class WebBarcodeService {\r\n    scanError$: Observable<Error>;\r\n    scanFailure$: Observable<Error>;\r\n    scanComplete$: Observable<Result>;\r\n    scanSuccess$: Observable<string>;\r\n\r\n    private _device: MediaDeviceInfo | undefined = undefined;\r\n    private _videoEl: HTMLVideoElement;\r\n    private _codeReader: BrowserMultiFormatContinuousReader | undefined = undefined;\r\n    private _hints: Map<DecodeHintType, any> = new Map<DecodeHintType, any>();\r\n    private _scanErrorSource = new Subject<Error>();\r\n    private _scanFailureSource = new Subject<Error>();\r\n    private _scanSubscription: any;\r\n    private _scanCompleteSource = new Subject<Result>();\r\n    private _scanSuccessSource = new Subject<Result>();\r\n    private _options: {\r\n        delayBetweenScanAttempts: number;\r\n        delayBetweenScanSuccess: number;\r\n    } = {\r\n        delayBetweenScanAttempts: 50,\r\n        delayBetweenScanSuccess: 500\r\n    };\r\n\r\n    constructor(public userMediaService: UserMediaBaseService) {\r\n        this.scanError$ = this._scanErrorSource.asObservable();\r\n        this.scanFailure$ = this._scanFailureSource.asObservable();\r\n        this.scanComplete$ = this._scanCompleteSource.asObservable();\r\n        this.scanSuccess$ = this._scanSuccessSource.asObservable().pipe(map((c) => c.getText()));\r\n    }\r\n\r\n    public startScan(device: MediaDeviceInfo, videoEl: HTMLVideoElement, options = this._options): void {\r\n        // instantly stops the scan before changing devices\r\n        this.scanStop();\r\n\r\n        // correctly sets the new (or none) device\r\n        this._device = device || undefined;\r\n        this._videoEl = videoEl;\r\n        this._options = options;\r\n        if (!this._device) {\r\n            // cleans the video because user removed the device\r\n            BrowserCodeReader.cleanVideoSource(videoEl);\r\n        }\r\n        if (this._scanSubscription) {\r\n            throw new Error('There is already a scan proccess running.');\r\n        }\r\n\r\n        if (!this._device) {\r\n            throw new Error('No device defined, cannot start scan, please define a device.');\r\n        }\r\n\r\n        // if enabled, starts scanning\r\n        if (device) {\r\n            this.scanFromDevice(device.deviceId);\r\n        }\r\n    }\r\n    public setFormat(input: BarcodeFormat[]): void {\r\n        if (typeof input === 'string') {\r\n            throw new Error('Invalid formats, make sure the [formats] input is a binding.');\r\n        }\r\n\r\n        // formats may be set from html template as BarcodeFormat or string array\r\n        const formats = input.map((f) => this.getBarcodeFormatOrFail(f));\r\n\r\n        const hints = this._hints;\r\n\r\n        // updates the hints\r\n        hints.set(DecodeHintType.POSSIBLE_FORMATS, formats);\r\n\r\n        // handles updating the codeReader\r\n        this._hints = hints;\r\n    }\r\n    public scanStop(): void {\r\n        if (this._scanSubscription) {\r\n            this._codeReader?.getScannerControls().stop();\r\n            this._scanSubscription?.unsubscribe();\r\n            this._scanSubscription = undefined;\r\n        }\r\n        // this.torchCompatible.next(false);\r\n    }\r\n\r\n    public destroy(): void {\r\n        // @note apenas necessario por enquanto causa da Torch\r\n        this.scanStop();\r\n        this._codeReader = undefined;\r\n        this._device = undefined;\r\n    }\r\n\r\n    private getBarcodeFormatOrFail(format: string | BarcodeFormat): BarcodeFormat {\r\n        return typeof format === 'string' ? BarcodeFormat[format.trim().toUpperCase()] : format;\r\n    }\r\n    private async scanFromDevice(deviceId: string): Promise<void> {\r\n        const videoElement = this._videoEl;\r\n\r\n        const codeReader = this.getCodeReader();\r\n\r\n        const scanStream = await codeReader.scanFromDeviceObservable(deviceId, videoElement);\r\n\r\n        if (!scanStream) {\r\n            throw new Error('Undefined decoding stream, aborting.');\r\n        }\r\n\r\n        const next = (x: ResultAndError): void => this._onDecodeResult(x.result, x.error);\r\n        const error = (err: any): void => this._onDecodeError(err);\r\n        const complete = (): void => {};\r\n\r\n        this._scanSubscription = scanStream.subscribe(next, error, complete);\r\n\r\n        if (this._scanSubscription.closed) {\r\n            return;\r\n        }\r\n\r\n        // const controls = codeReader.getScannerControls();\r\n        // const hasTorchControl = typeof controls.switchTorch !== 'undefined';\r\n\r\n        // this.torchCompatible.next(hasTorchControl);\r\n    }\r\n    /**\r\n     * Handles decode errors.\r\n     */\r\n    private _onDecodeError(err: any): void {\r\n        this._scanErrorSource.next(err);\r\n        // this.reset();\r\n    }\r\n    /**\r\n     * Handles decode results.\r\n     */\r\n    private _onDecodeResult(result: Result | undefined, error: Exception | undefined): void {\r\n        if (result) {\r\n            this._scanSuccessSource.next(result);\r\n        } else {\r\n            this._scanFailureSource.next(error as Error);\r\n        }\r\n        if (result) {\r\n            this._scanCompleteSource.next(result);\r\n        }\r\n    }\r\n    private getCodeReader(): BrowserMultiFormatContinuousReader {\r\n        if (!this._codeReader) {\r\n            this._codeReader = new BrowserMultiFormatContinuousReader(this._hints, this._options);\r\n        }\r\n\r\n        return this._codeReader;\r\n    }\r\n}\r\n"]}

package/esm2020/lib/barsa-develop-components.module.mjs

@@ -0,0 +1,224 @@
+import { CUSTOM_ELEMENTS_SCHEMA, NgModule, NO_ERRORS_SCHEMA } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { FormsModule, ReactiveFormsModule } from '@angular/forms';
+import { FundamentalNgxPlatformModule } from '@fundamental-ngx/platform';
+import { FundamentalNgxCoreModule } from '@fundamental-ngx/core';
+import { BarsaNovinRayCoreModule, BaseModule } from 'barsa-novin-ray-core';
+import { BarsaSapUiModule } from 'barsa-sap-ui';
+import { BarsaTilesModule } from 'barsa-tiles';
+import { BarsaEchartsModule } from 'barsa-echarts';
+import { LoginFormComponent } from './login-form/login-form.component';
+import { LoginSocialConncetionsComponent } from './login-social-conncetions/login-social-conncetions.component';
+import { UiPersonComponent } from './ui-person/ui-person.component';
+import { UiPersonPipe } from './ui-person/ui-person.pipe';
+import { BarcodeReaderComponent } from './barcode-reader/barcode-reader.component';
+import { BarcodeReaderDialogComponent } from './barcode-reader-dialog/barcode-reader-dialog.component';
+import { BarcodeReaderVideoComponent } from './barcode-reader-video/barcode-reader-video.component';
+import { UserMediaBaseService, WebBarcodeService } from './barcode.service';
+import { SettingFormComponent } from './setting-form/setting-form.component';
+import { MicroProcessFlowViewComponent } from './micro-process-flow-view/micro-process-flow-view.component';
+import { UiEnumSegmentedButtonComponent } from './ui-enum-segmented-button/ui-enum-segmented-button.component';
+import { TabProcessViewComponent } from './tab-process-view/tab-process-view.component';
+import { UiTextFieldSearchComponent } from './ui-text-field-search/ui-text-field-search.component';
+import { BarcodeFormatPipe } from './barcode-format-pipe';
+import { ServiceDeskHeaderComponent } from './service-desk-header/service-desk-header.component';
+import { CardContentImageAndTitleComponent } from './card-content-image-and-title/card-content-image-and-title.component';
+import { CardHeaderLogoTitleSubtitleComponent } from './card-header-logo-title-subtitle/card-header-logo-title-subtitle.component';
+import { FormContentQuickViewComponent } from './form-content-quick-view/form-content-quick-view.component';
+import { ServiceDeskServcieDetailComponent } from './service-desk-servcie-detail/service-desk-servcie-detail.component';
+import { ServiceDeskViewOfServicesComponent } from './service-desk-view-of-services/service-desk-view-of-services.component';
+import { ServiceDeskCardContentMojavezhayAkhzShodeComponent } from './service-desk-card-content-mojavezhay-akhz-shode/service-desk-card-content-mojavezhay-akhz-shode.component';
+import { CardHeaderBigImageTitleAndSubtitleComponent } from './card-header-big-image-title-and-subtitle/card-header-big-image-title-and-subtitle.component';
+import { ServiceDeskFormLayoutContentMojavezComponent } from './service-desk-form-layout-content-mojavez/service-desk-form-layout-content-mojavez.component';
+import { UlvContextMenuItemShowFileContentComponent } from './ulv-context-menu-item-show-file-content/ulv-context-menu-item-show-file-content.component';
+import { ResendVerificationCodeComponent } from './resend-verification-code/resend-verification-code.component';
+import { CheckboxButtonComponent } from './checkbox-button/checkbox-button.component';
+import { ReportTabViewComponent } from './report-tab-view/report-tab-view.component';
+import { ReportLineChartViewComponent } from './report-line-chart-view/report-line-chart-view.component';
+import { CardHeaderKpiComponent } from './card-header-kpi/card-header-kpi.component';
+import { CardContentLineChartComponent } from './card-content-line-chart/card-content-line-chart.component';
+import { FormChartContentComponent } from './form-chart-content/form-chart-content.component';
+import { TableViewVerticalColumnsComponent } from './table-view-vertical-columns/table-view-vertical-columns.component';
+import { QueryStringObservableComponent } from './query-string-observable/query-string-observable.component';
+import { QueryStringFormObservableComponent } from './query-string-form-observable/query-string-form-observable.component';
+import { G4bDetailsComponent } from './g4b-details/g4b-details.component';
+import { AvatarComponent } from './avatar/avatar.component';
+import { G4bEstelamComponent } from './g4b-estelam/g4b-estelam.component';
+import { TimerCountDownComponent } from './timer-count-down/timer-count-down.component';
+import { MoInfoMicroProccessFlowComponent } from './mo-info-micro-proccess-flow/mo-info-micro-proccess-flow.component';
+import { MicroProccessFlowComponent } from './micro-proccess-flow/micro-proccess-flow.component';
+import { EnumInfoMicroProccessFlowComponent } from './enum-info-micro-proccess-flow/enum-info-micro-proccess-flow.component';
+import { DataSourceToFlowItemPipe, MoListToFlowItemPipe } from './pipes';
+import { UiPicturesCarouselComponent } from './ui-pictures-carousel/ui-pictures-carousel.component';
+import { UiNumRateComponent } from './ui-num-rate/ui-num-rate.component';
+import * as i0 from "@angular/core";
+import * as i1 from "barsa-novin-ray-core";
+const components = [
+    LoginFormComponent,
+    LoginSocialConncetionsComponent,
+    UiPersonComponent,
+    BarcodeReaderComponent,
+    BarcodeReaderDialogComponent,
+    BarcodeReaderVideoComponent,
+    SettingFormComponent,
+    MicroProcessFlowViewComponent,
+    UiEnumSegmentedButtonComponent,
+    TabProcessViewComponent,
+    UiTextFieldSearchComponent,
+    ServiceDeskHeaderComponent,
+    CardContentImageAndTitleComponent,
+    CardHeaderLogoTitleSubtitleComponent,
+    FormContentQuickViewComponent,
+    ServiceDeskServcieDetailComponent,
+    ServiceDeskViewOfServicesComponent,
+    ServiceDeskCardContentMojavezhayAkhzShodeComponent,
+    CardHeaderBigImageTitleAndSubtitleComponent,
+    ServiceDeskFormLayoutContentMojavezComponent,
+    UlvContextMenuItemShowFileContentComponent,
+    ResendVerificationCodeComponent,
+    CheckboxButtonComponent,
+    ReportTabViewComponent,
+    ReportLineChartViewComponent,
+    CardHeaderKpiComponent,
+    CardContentLineChartComponent,
+    FormChartContentComponent,
+    TableViewVerticalColumnsComponent,
+    QueryStringObservableComponent,
+    QueryStringFormObservableComponent,
+    G4bDetailsComponent,
+    AvatarComponent,
+    G4bEstelamComponent,
+    TimerCountDownComponent,
+    MoInfoMicroProccessFlowComponent,
+    MicroProccessFlowComponent,
+    EnumInfoMicroProccessFlowComponent,
+    UiPicturesCarouselComponent,
+    UiNumRateComponent
+];
+const pipes = [UiPersonPipe, BarcodeFormatPipe, MoListToFlowItemPipe, DataSourceToFlowItemPipe];
+export class BarsaDevelopComponentsModule extends BaseModule {
+    constructor(dcm, cfr) {
+        super(dcm, cfr, 'BarsaDevelopComponentsModule');
+        this.dcm = dcm;
+        this.cfr = cfr;
+        this.dynamicComponents = [...components];
+    }
+}
+BarsaDevelopComponentsModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: BarsaDevelopComponentsModule, deps: [{ token: i1.DynamicComponentService }, { token: i0.ComponentFactoryResolver }], target: i0.ɵɵFactoryTarget.NgModule });
+BarsaDevelopComponentsModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.2.7", ngImport: i0, type: BarsaDevelopComponentsModule, declarations: [LoginFormComponent,
+        LoginSocialConncetionsComponent,
+        UiPersonComponent,
+        BarcodeReaderComponent,
+        BarcodeReaderDialogComponent,
+        BarcodeReaderVideoComponent,
+        SettingFormComponent,
+        MicroProcessFlowViewComponent,
+        UiEnumSegmentedButtonComponent,
+        TabProcessViewComponent,
+        UiTextFieldSearchComponent,
+        ServiceDeskHeaderComponent,
+        CardContentImageAndTitleComponent,
+        CardHeaderLogoTitleSubtitleComponent,
+        FormContentQuickViewComponent,
+        ServiceDeskServcieDetailComponent,
+        ServiceDeskViewOfServicesComponent,
+        ServiceDeskCardContentMojavezhayAkhzShodeComponent,
+        CardHeaderBigImageTitleAndSubtitleComponent,
+        ServiceDeskFormLayoutContentMojavezComponent,
+        UlvContextMenuItemShowFileContentComponent,
+        ResendVerificationCodeComponent,
+        CheckboxButtonComponent,
+        ReportTabViewComponent,
+        ReportLineChartViewComponent,
+        CardHeaderKpiComponent,
+        CardContentLineChartComponent,
+        FormChartContentComponent,
+        TableViewVerticalColumnsComponent,
+        QueryStringObservableComponent,
+        QueryStringFormObservableComponent,
+        G4bDetailsComponent,
+        AvatarComponent,
+        G4bEstelamComponent,
+        TimerCountDownComponent,
+        MoInfoMicroProccessFlowComponent,
+        MicroProccessFlowComponent,
+        EnumInfoMicroProccessFlowComponent,
+        UiPicturesCarouselComponent,
+        UiNumRateComponent, UiPersonPipe, BarcodeFormatPipe, MoListToFlowItemPipe, DataSourceToFlowItemPipe], imports: [CommonModule,
+        BarsaNovinRayCoreModule,
+        ReactiveFormsModule,
+        BarsaSapUiModule,
+        BarsaEchartsModule,
+        BarsaTilesModule,
+        FundamentalNgxCoreModule,
+        FundamentalNgxPlatformModule,
+        FormsModule], exports: [LoginFormComponent,
+        LoginSocialConncetionsComponent,
+        UiPersonComponent,
+        BarcodeReaderComponent,
+        BarcodeReaderDialogComponent,
+        BarcodeReaderVideoComponent,
+        SettingFormComponent,
+        MicroProcessFlowViewComponent,
+        UiEnumSegmentedButtonComponent,
+        TabProcessViewComponent,
+        UiTextFieldSearchComponent,
+        ServiceDeskHeaderComponent,
+        CardContentImageAndTitleComponent,
+        CardHeaderLogoTitleSubtitleComponent,
+        FormContentQuickViewComponent,
+        ServiceDeskServcieDetailComponent,
+        ServiceDeskViewOfServicesComponent,
+        ServiceDeskCardContentMojavezhayAkhzShodeComponent,
+        CardHeaderBigImageTitleAndSubtitleComponent,
+        ServiceDeskFormLayoutContentMojavezComponent,
+        UlvContextMenuItemShowFileContentComponent,
+        ResendVerificationCodeComponent,
+        CheckboxButtonComponent,
+        ReportTabViewComponent,
+        ReportLineChartViewComponent,
+        CardHeaderKpiComponent,
+        CardContentLineChartComponent,
+        FormChartContentComponent,
+        TableViewVerticalColumnsComponent,
+        QueryStringObservableComponent,
+        QueryStringFormObservableComponent,
+        G4bDetailsComponent,
+        AvatarComponent,
+        G4bEstelamComponent,
+        TimerCountDownComponent,
+        MoInfoMicroProccessFlowComponent,
+        MicroProccessFlowComponent,
+        EnumInfoMicroProccessFlowComponent,
+        UiPicturesCarouselComponent,
+        UiNumRateComponent] });
+BarsaDevelopComponentsModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: BarsaDevelopComponentsModule, providers: [UserMediaBaseService, WebBarcodeService], imports: [CommonModule,
+        BarsaNovinRayCoreModule,
+        ReactiveFormsModule,
+        BarsaSapUiModule,
+        BarsaEchartsModule,
+        BarsaTilesModule,
+        FundamentalNgxCoreModule,
+        FundamentalNgxPlatformModule,
+        FormsModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: BarsaDevelopComponentsModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [...components, ...pipes],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA, NO_ERRORS_SCHEMA],
+                    imports: [
+                        CommonModule,
+                        BarsaNovinRayCoreModule,
+                        ReactiveFormsModule,
+                        BarsaSapUiModule,
+                        BarsaEchartsModule,
+                        BarsaTilesModule,
+                        FundamentalNgxCoreModule,
+                        FundamentalNgxPlatformModule,
+                        FormsModule
+                    ],
+                    providers: [UserMediaBaseService, WebBarcodeService],
+                    exports: [...components]
+                }]
+        }], ctorParameters: function () { return [{ type: i1.DynamicComponentService }, { type: i0.ComponentFactoryResolver }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"barsa-develop-components.module.js","sourceRoot":"","sources":["../../../../projects/barsa-develop-components/src/lib/barsa-develop-components.module.ts"],"names":[],"mappings":"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","sourcesContent":["import { ComponentFactoryResolver, CUSTOM_ELEMENTS_SCHEMA, NgModule, NO_ERRORS_SCHEMA } from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport { FormsModule, ReactiveFormsModule } from '@angular/forms';\nimport { FundamentalNgxPlatformModule } from '@fundamental-ngx/platform';\nimport { FundamentalNgxCoreModule } from '@fundamental-ngx/core';\n\nimport { BarsaNovinRayCoreModule, BaseModule, DynamicComponentService } from 'barsa-novin-ray-core';\nimport { BarsaSapUiModule } from 'barsa-sap-ui';\nimport { BarsaTilesModule } from 'barsa-tiles';\nimport { BarsaEchartsModule } from 'barsa-echarts';\n\nimport { LoginFormComponent } from './login-form/login-form.component';\nimport { LoginSocialConncetionsComponent } from './login-social-conncetions/login-social-conncetions.component';\nimport { UiPersonComponent } from './ui-person/ui-person.component';\nimport { UiPersonPipe } from './ui-person/ui-person.pipe';\nimport { BarcodeReaderComponent } from './barcode-reader/barcode-reader.component';\nimport { BarcodeReaderDialogComponent } from './barcode-reader-dialog/barcode-reader-dialog.component';\nimport { BarcodeReaderVideoComponent } from './barcode-reader-video/barcode-reader-video.component';\nimport { UserMediaBaseService, WebBarcodeService } from './barcode.service';\nimport { SettingFormComponent } from './setting-form/setting-form.component';\nimport { MicroProcessFlowViewComponent } from './micro-process-flow-view/micro-process-flow-view.component';\nimport { UiEnumSegmentedButtonComponent } from './ui-enum-segmented-button/ui-enum-segmented-button.component';\nimport { TabProcessViewComponent } from './tab-process-view/tab-process-view.component';\nimport { UiTextFieldSearchComponent } from './ui-text-field-search/ui-text-field-search.component';\nimport { BarcodeFormatPipe } from './barcode-format-pipe';\nimport { ServiceDeskHeaderComponent } from './service-desk-header/service-desk-header.component';\nimport { CardContentImageAndTitleComponent } from './card-content-image-and-title/card-content-image-and-title.component';\nimport { CardHeaderLogoTitleSubtitleComponent } from './card-header-logo-title-subtitle/card-header-logo-title-subtitle.component';\nimport { FormContentQuickViewComponent } from './form-content-quick-view/form-content-quick-view.component';\nimport { ServiceDeskServcieDetailComponent } from './service-desk-servcie-detail/service-desk-servcie-detail.component';\nimport { ServiceDeskViewOfServicesComponent } from './service-desk-view-of-services/service-desk-view-of-services.component';\nimport { ServiceDeskCardContentMojavezhayAkhzShodeComponent } from './service-desk-card-content-mojavezhay-akhz-shode/service-desk-card-content-mojavezhay-akhz-shode.component';\nimport { CardHeaderBigImageTitleAndSubtitleComponent } from './card-header-big-image-title-and-subtitle/card-header-big-image-title-and-subtitle.component';\nimport { ServiceDeskFormLayoutContentMojavezComponent } from './service-desk-form-layout-content-mojavez/service-desk-form-layout-content-mojavez.component';\nimport { UlvContextMenuItemShowFileContentComponent } from './ulv-context-menu-item-show-file-content/ulv-context-menu-item-show-file-content.component';\nimport { ResendVerificationCodeComponent } from './resend-verification-code/resend-verification-code.component';\nimport { CheckboxButtonComponent } from './checkbox-button/checkbox-button.component';\nimport { ReportTabViewComponent } from './report-tab-view/report-tab-view.component';\nimport { ReportLineChartViewComponent } from './report-line-chart-view/report-line-chart-view.component';\nimport { CardHeaderKpiComponent } from './card-header-kpi/card-header-kpi.component';\nimport { CardContentLineChartComponent } from './card-content-line-chart/card-content-line-chart.component';\nimport { FormChartContentComponent } from './form-chart-content/form-chart-content.component';\nimport { TableViewVerticalColumnsComponent } from './table-view-vertical-columns/table-view-vertical-columns.component';\nimport { QueryStringObservableComponent } from './query-string-observable/query-string-observable.component';\nimport { QueryStringFormObservableComponent } from './query-string-form-observable/query-string-form-observable.component';\nimport { G4bDetailsComponent } from './g4b-details/g4b-details.component';\nimport { AvatarComponent } from './avatar/avatar.component';\nimport { G4bEstelamComponent } from './g4b-estelam/g4b-estelam.component';\nimport { TimerCountDownComponent } from './timer-count-down/timer-count-down.component';\nimport { MoInfoMicroProccessFlowComponent } from './mo-info-micro-proccess-flow/mo-info-micro-proccess-flow.component';\nimport { MicroProccessFlowComponent } from './micro-proccess-flow/micro-proccess-flow.component';\nimport { EnumInfoMicroProccessFlowComponent } from './enum-info-micro-proccess-flow/enum-info-micro-proccess-flow.component';\n\nimport { DataSourceToFlowItemPipe, MoListToFlowItemPipe } from './pipes';\nimport { UiPicturesCarouselComponent } from './ui-pictures-carousel/ui-pictures-carousel.component';\nimport { UiNumRateComponent } from './ui-num-rate/ui-num-rate.component';\n\nconst components = [\n    LoginFormComponent,\n    LoginSocialConncetionsComponent,\n    UiPersonComponent,\n    BarcodeReaderComponent,\n    BarcodeReaderDialogComponent,\n    BarcodeReaderVideoComponent,\n    SettingFormComponent,\n    MicroProcessFlowViewComponent,\n    UiEnumSegmentedButtonComponent,\n    TabProcessViewComponent,\n    UiTextFieldSearchComponent,\n    ServiceDeskHeaderComponent,\n    CardContentImageAndTitleComponent,\n    CardHeaderLogoTitleSubtitleComponent,\n    FormContentQuickViewComponent,\n    ServiceDeskServcieDetailComponent,\n    ServiceDeskViewOfServicesComponent,\n    ServiceDeskCardContentMojavezhayAkhzShodeComponent,\n    CardHeaderBigImageTitleAndSubtitleComponent,\n    ServiceDeskFormLayoutContentMojavezComponent,\n    UlvContextMenuItemShowFileContentComponent,\n    ResendVerificationCodeComponent,\n    CheckboxButtonComponent,\n    ReportTabViewComponent,\n    ReportLineChartViewComponent,\n    CardHeaderKpiComponent,\n    CardContentLineChartComponent,\n    FormChartContentComponent,\n    TableViewVerticalColumnsComponent,\n    QueryStringObservableComponent,\n    QueryStringFormObservableComponent,\n    G4bDetailsComponent,\n    AvatarComponent,\n    G4bEstelamComponent,\n    TimerCountDownComponent,\n    MoInfoMicroProccessFlowComponent,\n    MicroProccessFlowComponent,\n    EnumInfoMicroProccessFlowComponent,\n    UiPicturesCarouselComponent,\n    UiNumRateComponent\n];\nconst pipes = [UiPersonPipe, BarcodeFormatPipe, MoListToFlowItemPipe, DataSourceToFlowItemPipe];\n@NgModule({\n    declarations: [...components, ...pipes],\n    schemas: [CUSTOM_ELEMENTS_SCHEMA, NO_ERRORS_SCHEMA],\n    imports: [\n        CommonModule,\n        BarsaNovinRayCoreModule,\n        ReactiveFormsModule,\n        BarsaSapUiModule,\n        BarsaEchartsModule,\n        BarsaTilesModule,\n        FundamentalNgxCoreModule,\n        FundamentalNgxPlatformModule,\n        FormsModule\n    ],\n    providers: [UserMediaBaseService, WebBarcodeService],\n    exports: [...components]\n})\nexport class BarsaDevelopComponentsModule extends BaseModule {\n    protected dynamicComponents = [...components];\n    constructor(protected dcm: DynamicComponentService, protected cfr: ComponentFactoryResolver) {\n        super(dcm, cfr, 'BarsaDevelopComponentsModule');\n    }\n}\n"]}