ngx-scandoc 0.0.1 → 1.0.2

package/dialogs/components/scan-selfie/scan-selfie.component.d.ts

@@ -0,0 +1,83 @@
+import { EventEmitter, ElementRef, ChangeDetectorRef, AfterViewInit } from '@angular/core';
+import { MatDialogRef } from '@angular/material/dialog';
+import { Subject, Observable } from 'rxjs';
+import { FormGroup } from '@angular/forms';
+import { WebcamImage } from '../../../core/components/webcam/domain/webcam-image';
+import { WebcamInitError } from '../../../core/components/webcam/domain/webcam-init-error';
+import { DialogsCoreProvider } from '../../../dialogs/dialogs.core.provider';
+import { TranslateService } from '@ngx-translate/core';
+import { ScanProvider } from '../../../providers/scan.provider';
+import * as i0 from "@angular/core";
+export interface IWindow extends Window {
+    TextDetector: any;
+}
+export declare class ScanSelfieComponent implements AfterViewInit {
+    cd: ChangeDetectorRef;
+    scanProvider: ScanProvider;
+    private dialogs;
+    private translate;
+    scanBlastData: any;
+    type: string;
+    actions: EventEmitter<any>;
+    mediaDevices: any;
+    deviceId?: string;
+    videoOptions: MediaTrackConstraints;
+    dialogRef?: MatDialogRef<any>;
+    data: any;
+    multipleWebcamsAvailable: boolean;
+    fields: any;
+    documentTypeSelected: boolean;
+    selectedSide: any;
+    images: any;
+    preview: any;
+    scanType: any;
+    width: any;
+    height: any;
+    videoWidth: any;
+    videoHeight: any;
+    allowCameraSwitch: boolean;
+    error: boolean;
+    cameraReady: boolean;
+    result: any;
+    scaning: boolean;
+    defaultDevice: any;
+    scanDatas: any;
+    scanSide: any;
+    webcamImage?: WebcamImage;
+    model: any;
+    trigger: Subject<number>;
+    nextWebcam: Subject<boolean | string>;
+    form: FormGroup<{}>;
+    wraper?: ElementRef;
+    onResize(): void;
+    constructor(cd: ChangeDetectorRef, scanProvider: ScanProvider, dialogs: DialogsCoreProvider, translate: TranslateService);
+    init(): void;
+    handleImage(webcamImage: WebcamImage): void;
+    handleInitError(error: WebcamInitError): void;
+    get scanBlastCanUpload(): boolean;
+    cameraWasSwitched(deviceId: string): void;
+    get nextWebcamObservable(): Observable<boolean | string>;
+    ngAfterViewInit(): void;
+    selectCamera(event: any): void;
+    close(): void;
+    singleScan(side: any): void;
+    getBase64(file: any): Observable<unknown>;
+    handleFileInput(target: any, event: any, side: any): void;
+    rotateBase64Image(base64data: any): Observable<unknown>;
+    sendMobile(): void;
+    singleScanRotate(side: any): void;
+    singleScanRemove(side: any): void;
+    resolutionLimit(file: any): Observable<unknown>;
+    private getImgBase64;
+    scanBlastFinish(): void;
+    cameraOff(ev: any): void;
+    continue(): void;
+    retry(): void;
+    triggerSnapshot(): void;
+    scan(): void;
+    retake(): void;
+    use(): void;
+    selfie(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScanSelfieComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ScanSelfieComponent, "app-scan-selfie", never, { "type": "type"; }, { "actions": "actions"; }, never, never, false>;
+}

package/dialogs/components/turn-document/turn-document.component.d.ts

@@ -0,0 +1,12 @@
+import { OnInit } from '@angular/core';
+import { MatDialogRef } from '@angular/material/dialog';
+import * as i0 from "@angular/core";
+export declare class TurnDocumentComponent implements OnInit {
+    dialogRef: MatDialogRef<TurnDocumentComponent>;
+    data: any;
+    constructor(dialogRef: MatDialogRef<TurnDocumentComponent>, data: any);
+    ngOnInit(): void;
+    close(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TurnDocumentComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TurnDocumentComponent, "app-turndocuments", never, {}, {}, never, never, false>;
+}

package/dialogs/dialogs.core.provider.d.ts

@@ -0,0 +1,18 @@
+import { MatDialog, MatDialogRef } from '@angular/material/dialog';
+import { BlankComponent } from './components/blank/blank.component';
+import * as i0 from "@angular/core";
+export declare class DialogsCoreProvider {
+    private matDialog;
+    components: any;
+    private blank;
+    constructor(matDialog: MatDialog);
+    private getComponent;
+    open(config: any, withComponent?: boolean): MatDialogRef<BlankComponent, any>;
+    scanProfile(data: any): MatDialogRef<BlankComponent, any>;
+    loading(title?: string): MatDialogRef<BlankComponent, any>;
+    alert(title: string, text: string): MatDialogRef<BlankComponent, any>;
+    turnDocument(idScan: any): import("rxjs").Observable<any>;
+    scanSelfie(data: any): MatDialogRef<BlankComponent, any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogsCoreProvider, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DialogsCoreProvider>;
+}

package/dialogs/dialogs.module.d.ts

@@ -0,0 +1,21 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./components/scan-profile/scan-profile.component";
+import * as i2 from "./components/blank/blank.component";
+import * as i3 from "./components/loading/loading.component";
+import * as i4 from "./components/confirm/confirm.component";
+import * as i5 from "./components/turn-document/turn-document.component";
+import * as i6 from "./components/scan-selfie/scan-selfie.component";
+import * as i7 from "angularx-qrcode";
+import * as i8 from "@angular/forms";
+import * as i9 from "@angular/common";
+import * as i10 from "../forms/form.module";
+import * as i11 from "@ngx-translate/core";
+import * as i12 from "../core/shared/material.module";
+import * as i13 from "../core/components/components.module";
+import * as i14 from "../core/pipes/pipes.module";
+import * as i15 from "@angular/flex-layout";
+export declare class DialogsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DialogsModule, [typeof i1.ScanProfileComponent, typeof i2.BlankComponent, typeof i3.LoadingComponent, typeof i4.ConfirmComponent, typeof i5.TurnDocumentComponent, typeof i6.ScanSelfieComponent], [typeof i7.QRCodeModule, typeof i8.ReactiveFormsModule, typeof i9.CommonModule, typeof i8.FormsModule, typeof i10.AppFormModule, typeof i11.TranslateModule, typeof i12.MaterialModule, typeof i13.CoreComponentsModule, typeof i14.CorePipesModule, typeof i15.FlexModule, typeof i15.FlexLayoutModule], [typeof i1.ScanProfileComponent, typeof i3.LoadingComponent, typeof i2.BlankComponent, typeof i5.TurnDocumentComponent, typeof i12.MaterialModule, typeof i6.ScanSelfieComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DialogsModule>;
+}

package/esm2020/core/app.worker.mjs

@@ -0,0 +1,236 @@
+export const workertext = `
+
+
+let readStream = true;
+async function blobToBase64(blob) {
+  return new Promise((resolve, _) => {
+    const reader = new FileReader();
+    reader.onloadend = () => resolve(reader.result);
+    reader.readAsDataURL(blob);
+  });
+}
+async function delay(ms) {
+  return new Promise((resolve) =>
+    ms > 0 ? setTimeout(resolve, ms) : resolve(0)
+  );
+}
+
+function calculateDelay(startTime) {
+  const endTime = Date.now();
+  // difference in ms
+  const dt = endTime - startTime;
+  const delay = 100 - dt;
+ // console.log('[WORKER TIME]', dt, '[DELAY 100-x]', delay);
+  return delay > 4 ? delay : 0;
+}
+async function parseFrame(frameStream, trackSettings) {
+  const reader = frameStream.getReader();
+
+  while (readStream) {
+    const time = Date.now();
+    const result = await reader.read();
+    if (result.done) break;
+
+    const frameFromCamera = result.value;
+
+    await parseFrameFromCamera(frameFromCamera, trackSettings);
+    // wait
+    await delay(calculateDelay(time));
+  }
+}
+
+async function parseFrameFast(frameStream, trackSettings) {
+  console.warn('FAST', performance.now());
+  const reader = frameStream.getReader();
+  const { width, height } = trackSettings;
+  const offscreenSmall = new OffscreenCanvas(384, 384);
+  const context = offscreenSmall.getContext('2d');
+  let time = 0;
+  while (true) {
+    // const t0 = performance.now();
+    //  console.time('result');
+    const result = reader.read();
+    //  console.timeEnd('result');
+    if (result.done) break;
+
+    const frameFromCamera = result.value;
+    // console.log(frameFromCamera.timestamp);
+
+    // const tt = frameFromCamera.timestamp - time;
+    // console.log(tt / 1000);
+    // time = frameFromCamera.timestamp;
+
+    // console.time('bitmap');
+    const bitmap = await createImageBitmap(frameFromCamera, {
+      premultiplyAlpha: 'default',
+    });
+    console.warn(new Date().getTime());
+    // console.timeEnd('bitmap');
+
+    // context.clearRect(0, 0, 384, 384);
+    // console.time('draw');
+    // context.drawImage(bitmap, 0, 0, width, height, 0, 0, 384, 384);
+    // console.timeEnd('draw');
+    // console.time('transfer');
+    // const bitmapSmall = offscreenSmall.transferToImageBitmap();
+    // console.timeEnd('transfer');
+
+    frameFromCamera.close();
+    // //
+    // const t1 = performance.now();
+
+
+    // await parseFrameFromCamera(frameFromCamera, trackSettings);
+  }
+}
+
+async function parseFrameFromCamera(frameFromCamera, trackSettings) {
+  const { width, height } = trackSettings;
+  const offscreenSmall = new OffscreenCanvas(384, 384);
+  // console.time('bit2');
+  const bitmap = await createImageBitmap(frameFromCamera, {
+    premultiplyAlpha: 'default',
+  });
+  // console.timeEnd('bit2');
+  const context = offscreenSmall.getContext('2d');
+
+  //      console.time('buffer');
+  //      const buffer = new Uint8Array(frameFromCamera.allocationSize());
+  //      let layout = await frameFromCamera.copyTo(buffer);
+
+  //       const base64 = await blobToBase64(new Blob([buffer]));
+  // console.log(base64)
+  //      console.timeEnd('buffer');
+
+  if (context) {
+    context.imageSmoothingEnabled = false;
+
+    // let videoFrame2 = frameFromCamera.clone();
+
+    //   createImageBitmap();
+
+    // console.time('clear');
+    // context.clearRect(0, 0, width, height);
+    //  console.timeEnd('clear');
+    // console.time('draw');
+    context.drawImage(bitmap, 0, 0, width, height, 0, 0, 384, 384);
+    // console.timeEnd('draw');
+    // context.drawImage(bit, 0, 0);
+    //  bit2.close();
+    //  bit.close();
+    //  console.timeEnd('draw');
+    // console.time('capture');
+
+    // const bitmapsmall = offscreenSmall.transferToImageBitmap();
+
+    // const imageData = context.getImageData(0, 0, 384, 384);
+    //  console.timeEnd('capture');
+    // console.time('blob');
+    const resized = await offscreenSmall.convertToBlob({
+      type: 'image/jpeg',
+    });
+    // console.timeEnd('blob');
+    //  console.log(resized);
+    //  console.time('base64');
+    const base64 = await blobToBase64(resized);
+    //console.timeEnd('base64');
+    // console.log(blob);
+
+    // console.time('convert')
+    // await convert(bitmap, trackSettings)
+    // console.timeEnd('convert');
+    // console.log(
+    //   '%c ',
+    //   'font-size:384px; background:url('+blob+') no-repeat;'
+    // );
+
+    //   console.timeEnd('blob');
+    postMessage({ base64, bitmap }, [bitmap]);
+    // videoFrame2.close();
+  }
+  frameFromCamera.close();
+}
+
+async function convert(image, trackSettings) {
+  const { width, height } = trackSettings;
+
+  const offscreenSmall = new OffscreenCanvas(width, height);
+
+  const context = offscreenSmall.getContext('2d');
+
+  // console.time('buffer');
+  // const buffer = new Uint8Array(frameFromCamera.allocationSize());
+  // let layout = await frameFromCamera.copyTo(buffer);
+  // console.timeEnd('buffer');
+
+  if (context) {
+    context.imageSmoothingEnabled = false;
+    // let videoFrame2 = frameFromCamera.clone();
+    console.warn(image);
+    //   createImageBitmap();
+
+    // console.time('clear');
+    // context.clearRect(0, 0, width, height);
+    // console.timeEnd('clear');
+
+    context.drawImage(image, 0, 0);
+    // context.drawImage(bit, 0, 0);
+    // image.close();
+    // console.timeEnd('drawB');
+    console.time('blob2');
+    const resized = await offscreenSmall.convertToBlob({
+      type: 'image/jpeg',
+    });
+    console.timeEnd('blob2');
+
+    // image.close();
+    // console.time('base64');
+    const base64 = await blobToBase64(resized);
+
+    // console.log(blob);
+
+    // console.log(
+    //   '%c ',
+    //   'font-size:384px; background:url(' + base64 + ') no-repeat;'
+    // );
+
+    //  console.timeEnd('base64');
+    //postMessage({ type: 'convert', base64 });
+  }
+}
+addEventListener('message', ({ data }) => {
+  const { type, image, frameStream, trackSettings } = data;
+  // console.log(data);
+  switch (type) {
+    case 'start':
+      readStream = true;
+      parseFrame(frameStream, trackSettings);
+      break;
+
+    case 'fast':
+      readStream = true;
+      parseFrameFast(frameStream, trackSettings);
+      break;
+
+    case 'stop':
+      console.warn('STOP WORKER');
+      readStream = false;
+      break;
+
+    case 'convert':
+      convert(image, trackSettings);
+      break;
+  }
+
+  // const canvas = document.createElement('canvas');
+  // const ctx = canvas.getContext('2d');
+
+  // if (data.canvas) {
+  //   postMessage('ok');
+  // } else {
+
+  //   postMessage(response);
+  // }
+});
+`;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"app.worker.js","sourceRoot":"","sources":["../../../../projects/ngx-scandoc/src/core/app.worker.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,UAAU,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0OzB,CAAC","sourcesContent":["export const workertext = `\n\n\nlet readStream = true;\nasync function blobToBase64(blob) {\n  return new Promise((resolve, _) => {\n    const reader = new FileReader();\n    reader.onloadend = () => resolve(reader.result);\n    reader.readAsDataURL(blob);\n  });\n}\nasync function delay(ms) {\n  return new Promise((resolve) =>\n    ms > 0 ? setTimeout(resolve, ms) : resolve(0)\n  );\n}\n\nfunction calculateDelay(startTime) {\n  const endTime = Date.now();\n  // difference in ms\n  const dt = endTime - startTime;\n  const delay = 100 - dt;\n // console.log('[WORKER TIME]', dt, '[DELAY 100-x]', delay);\n  return delay > 4 ? delay : 0;\n}\nasync function parseFrame(frameStream, trackSettings) {\n  const reader = frameStream.getReader();\n\n  while (readStream) {\n    const time = Date.now();\n    const result = await reader.read();\n    if (result.done) break;\n\n    const frameFromCamera = result.value;\n\n    await parseFrameFromCamera(frameFromCamera, trackSettings);\n    // wait\n    await delay(calculateDelay(time));\n  }\n}\n\nasync function parseFrameFast(frameStream, trackSettings) {\n  console.warn('FAST', performance.now());\n  const reader = frameStream.getReader();\n  const { width, height } = trackSettings;\n  const offscreenSmall = new OffscreenCanvas(384, 384);\n  const context = offscreenSmall.getContext('2d');\n  let time = 0;\n  while (true) {\n    // const t0 = performance.now();\n    //  console.time('result');\n    const result = reader.read();\n    //  console.timeEnd('result');\n    if (result.done) break;\n\n    const frameFromCamera = result.value;\n    // console.log(frameFromCamera.timestamp);\n\n    // const tt = frameFromCamera.timestamp - time;\n    // console.log(tt / 1000);\n    // time = frameFromCamera.timestamp;\n\n    // console.time('bitmap');\n    const bitmap = await createImageBitmap(frameFromCamera, {\n      premultiplyAlpha: 'default',\n    });\n    console.warn(new Date().getTime());\n    // console.timeEnd('bitmap');\n\n    // context.clearRect(0, 0, 384, 384);\n    // console.time('draw');\n    // context.drawImage(bitmap, 0, 0, width, height, 0, 0, 384, 384);\n    // console.timeEnd('draw');\n    // console.time('transfer');\n    // const bitmapSmall = offscreenSmall.transferToImageBitmap();\n    // console.timeEnd('transfer');\n\n    frameFromCamera.close();\n    // //\n    // const t1 = performance.now();\n\n\n    // await parseFrameFromCamera(frameFromCamera, trackSettings);\n  }\n}\n\nasync function parseFrameFromCamera(frameFromCamera, trackSettings) {\n  const { width, height } = trackSettings;\n  const offscreenSmall = new OffscreenCanvas(384, 384);\n  // console.time('bit2');\n  const bitmap = await createImageBitmap(frameFromCamera, {\n    premultiplyAlpha: 'default',\n  });\n  // console.timeEnd('bit2');\n  const context = offscreenSmall.getContext('2d');\n\n  //      console.time('buffer');\n  //      const buffer = new Uint8Array(frameFromCamera.allocationSize());\n  //      let layout = await frameFromCamera.copyTo(buffer);\n\n  //       const base64 = await blobToBase64(new Blob([buffer]));\n  // console.log(base64)\n  //      console.timeEnd('buffer');\n\n  if (context) {\n    context.imageSmoothingEnabled = false;\n\n    // let videoFrame2 = frameFromCamera.clone();\n\n    //   createImageBitmap();\n\n    // console.time('clear');\n    // context.clearRect(0, 0, width, height);\n    //  console.timeEnd('clear');\n    // console.time('draw');\n    context.drawImage(bitmap, 0, 0, width, height, 0, 0, 384, 384);\n    // console.timeEnd('draw');\n    // context.drawImage(bit, 0, 0);\n    //  bit2.close();\n    //  bit.close();\n    //  console.timeEnd('draw');\n    // console.time('capture');\n\n    // const bitmapsmall = offscreenSmall.transferToImageBitmap();\n\n    // const imageData = context.getImageData(0, 0, 384, 384);\n    //  console.timeEnd('capture');\n    // console.time('blob');\n    const resized = await offscreenSmall.convertToBlob({\n      type: 'image/jpeg',\n    });\n    // console.timeEnd('blob');\n    //  console.log(resized);\n    //  console.time('base64');\n    const base64 = await blobToBase64(resized);\n    //console.timeEnd('base64');\n    // console.log(blob);\n\n    // console.time('convert')\n    // await convert(bitmap, trackSettings)\n    // console.timeEnd('convert');\n    // console.log(\n    //   '%c ',\n    //   'font-size:384px; background:url('+blob+') no-repeat;'\n    // );\n\n    //   console.timeEnd('blob');\n    postMessage({ base64, bitmap }, [bitmap]);\n    // videoFrame2.close();\n  }\n  frameFromCamera.close();\n}\n\nasync function convert(image, trackSettings) {\n  const { width, height } = trackSettings;\n\n  const offscreenSmall = new OffscreenCanvas(width, height);\n\n  const context = offscreenSmall.getContext('2d');\n\n  // console.time('buffer');\n  // const buffer = new Uint8Array(frameFromCamera.allocationSize());\n  // let layout = await frameFromCamera.copyTo(buffer);\n  // console.timeEnd('buffer');\n\n  if (context) {\n    context.imageSmoothingEnabled = false;\n    // let videoFrame2 = frameFromCamera.clone();\n    console.warn(image);\n    //   createImageBitmap();\n\n    // console.time('clear');\n    // context.clearRect(0, 0, width, height);\n    // console.timeEnd('clear');\n\n    context.drawImage(image, 0, 0);\n    // context.drawImage(bit, 0, 0);\n    // image.close();\n    // console.timeEnd('drawB');\n    console.time('blob2');\n    const resized = await offscreenSmall.convertToBlob({\n      type: 'image/jpeg',\n    });\n    console.timeEnd('blob2');\n\n    // image.close();\n    // console.time('base64');\n    const base64 = await blobToBase64(resized);\n\n    // console.log(blob);\n\n    // console.log(\n    //   '%c ',\n    //   'font-size:384px; background:url(' + base64 + ') no-repeat;'\n    // );\n\n    //  console.timeEnd('base64');\n    //postMessage({ type: 'convert', base64 });\n  }\n}\naddEventListener('message', ({ data }) => {\n  const { type, image, frameStream, trackSettings } = data;\n  // console.log(data);\n  switch (type) {\n    case 'start':\n      readStream = true;\n      parseFrame(frameStream, trackSettings);\n      break;\n\n    case 'fast':\n      readStream = true;\n      parseFrameFast(frameStream, trackSettings);\n      break;\n\n    case 'stop':\n      console.warn('STOP WORKER');\n      readStream = false;\n      break;\n\n    case 'convert':\n      convert(image, trackSettings);\n      break;\n  }\n\n  // const canvas = document.createElement('canvas');\n  // const ctx = canvas.getContext('2d');\n\n  // if (data.canvas) {\n  //   postMessage('ok');\n  // } else {\n\n  //   postMessage(response);\n  // }\n});\n`;\n"]}

package/esm2020/core/components/base.component.mjs

@@ -0,0 +1,15 @@
+import { Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+export class BaseComponent {
+    constructor() {
+        this.$destroy = new Subject();
+    }
+    __subs(observable) {
+        return observable.pipe(takeUntil(this.$destroy));
+    }
+    __destroy() {
+        this.$destroy.next(true);
+        this.$destroy.complete();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFzZS5jb21wb25lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtc2NhbmRvYy9zcmMvY29yZS9jb21wb25lbnRzL2Jhc2UuY29tcG9uZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBYyxPQUFPLEVBQUUsTUFBTSxNQUFNLENBQUM7QUFDM0MsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLGdCQUFnQixDQUFDO0FBRTNDLE1BQU0sT0FBTyxhQUFhO0lBQTFCO1FBQ0UsYUFBUSxHQUFHLElBQUksT0FBTyxFQUFFLENBQUM7SUFVM0IsQ0FBQztJQVJDLE1BQU0sQ0FBQyxVQUEyQjtRQUNoQyxPQUFPLFVBQVUsQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLElBQUksQ0FBQyxRQUFRLENBQUMsQ0FBQyxDQUFDO0lBQ25ELENBQUM7SUFFRCxTQUFTO1FBQ1AsSUFBSSxDQUFDLFFBQVEsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUM7UUFDekIsSUFBSSxDQUFDLFFBQVEsQ0FBQyxRQUFRLEVBQUUsQ0FBQztJQUMzQixDQUFDO0NBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBPYnNlcnZhYmxlLCBTdWJqZWN0IH0gZnJvbSAncnhqcyc7XG5pbXBvcnQgeyB0YWtlVW50aWwgfSBmcm9tICdyeGpzL29wZXJhdG9ycyc7XG5cbmV4cG9ydCBjbGFzcyBCYXNlQ29tcG9uZW50IHtcbiAgJGRlc3Ryb3kgPSBuZXcgU3ViamVjdCgpO1xuXG4gIF9fc3VicyhvYnNlcnZhYmxlOiBPYnNlcnZhYmxlPGFueT4pIHtcbiAgICByZXR1cm4gb2JzZXJ2YWJsZS5waXBlKHRha2VVbnRpbCh0aGlzLiRkZXN0cm95KSk7XG4gIH1cblxuICBfX2Rlc3Ryb3koKSB7XG4gICAgdGhpcy4kZGVzdHJveS5uZXh0KHRydWUpO1xuICAgIHRoaXMuJGRlc3Ryb3kuY29tcGxldGUoKTtcbiAgfVxufVxuIl19

package/esm2020/core/components/camera-switch/camera-switch.component.mjs

@@ -0,0 +1,22 @@
+import { Component, } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../providers/camera.provider";
+import * as i2 from "@angular/common";
+import * as i3 from "@angular/forms";
+import * as i4 from "@angular/material/form-field";
+import * as i5 from "@angular/material/select";
+import * as i6 from "@angular/material/core";
+export class CameraSwitchComponent {
+    constructor(cameraProvider) {
+        this.cameraProvider = cameraProvider;
+    }
+    ngAfterViewInit() { }
+    ngOnDestroy() { }
+}
+CameraSwitchComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: CameraSwitchComponent, deps: [{ token: i1.NgxScandocCameraProvider }], target: i0.ɵɵFactoryTarget.Component });
+CameraSwitchComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.3.0", type: CameraSwitchComponent, selector: "ngx-scan-camera-switch", ngImport: i0, template: "<mat-form-field\n  style=\"font-size: 14px; width: 200px; margin-top: 8px\"\n  class=\"w-100 mr-16 mt-8\"\n>\n  <mat-label> Camera </mat-label>\n  <mat-select (selectionChange)=\"cameraProvider.selectCamera($event)\" [(ngModel)]=\"cameraProvider.deviceId\">\n    <mat-option *ngFor=\"let device of cameraProvider.mediaDevices\" [value]=\"device.deviceId\">\n      {{ device.label }}\n    </mat-option>\n  </mat-select>\n</mat-form-field>\n", styles: [":host{display:flex;flex-direction:column!important;flex:1}\n"], dependencies: [{ kind: "directive", type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i3.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i3.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "component", type: i4.MatFormField, selector: "mat-form-field", inputs: ["color", "appearance", "hideRequiredMarker", "hintLabel", "floatLabel"], exportAs: ["matFormField"] }, { kind: "directive", type: i4.MatLabel, selector: "mat-label" }, { kind: "component", type: i5.MatSelect, selector: "mat-select", inputs: ["disabled", "disableRipple", "tabIndex"], exportAs: ["matSelect"] }, { kind: "component", type: i6.MatOption, selector: "mat-option", exportAs: ["matOption"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: CameraSwitchComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'ngx-scan-camera-switch', template: "<mat-form-field\n  style=\"font-size: 14px; width: 200px; margin-top: 8px\"\n  class=\"w-100 mr-16 mt-8\"\n>\n  <mat-label> Camera </mat-label>\n  <mat-select (selectionChange)=\"cameraProvider.selectCamera($event)\" [(ngModel)]=\"cameraProvider.deviceId\">\n    <mat-option *ngFor=\"let device of cameraProvider.mediaDevices\" [value]=\"device.deviceId\">\n      {{ device.label }}\n    </mat-option>\n  </mat-select>\n</mat-form-field>\n", styles: [":host{display:flex;flex-direction:column!important;flex:1}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.NgxScandocCameraProvider }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/core/components/components.module.mjs

@@ -0,0 +1,46 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { WebcamModule } from './webcam/webcam.module';
+import { ScanComponent } from './scan/scan.component';
+import { MaterialModule } from '../shared/material.module';
+import { AppFormModule } from '../../forms/form.module';
+import { FormsModule, ReactiveFormsModule } from '@angular/forms';
+import { TranslateModule } from '@ngx-translate/core';
+import { CameraSwitchComponent } from './camera-switch/camera-switch.component';
+import { ScanResultsComponent } from './scan-results/scan-results.component';
+import * as i0 from "@angular/core";
+export class CoreComponentsModule {
+}
+CoreComponentsModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: CoreComponentsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+CoreComponentsModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.3.0", ngImport: i0, type: CoreComponentsModule, declarations: [ScanComponent, ScanResultsComponent, CameraSwitchComponent], imports: [CommonModule,
+        FormsModule,
+        TranslateModule,
+        WebcamModule,
+        MaterialModule,
+        AppFormModule,
+        ReactiveFormsModule], exports: [WebcamModule, ScanComponent, CameraSwitchComponent] });
+CoreComponentsModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: CoreComponentsModule, imports: [CommonModule,
+        FormsModule,
+        TranslateModule,
+        WebcamModule,
+        MaterialModule,
+        AppFormModule,
+        ReactiveFormsModule, WebcamModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: CoreComponentsModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        CommonModule,
+                        FormsModule,
+                        TranslateModule,
+                        WebcamModule,
+                        MaterialModule,
+                        AppFormModule,
+                        ReactiveFormsModule,
+                    ],
+                    declarations: [ScanComponent, ScanResultsComponent, CameraSwitchComponent],
+                    exports: [WebcamModule, ScanComponent, CameraSwitchComponent],
+                    providers: [],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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