ngx-scandoc 0.0.1 → 1.0.1

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/scan-mobile/scan-mobile.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.ScanMobileComponent, 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.ScanMobileComponent, 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/components.module.mjs

@@ -0,0 +1,18 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { WebcamModule } from './webcam/webcam.module';
+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, imports: [CommonModule, WebcamModule], exports: [WebcamModule] });
+CoreComponentsModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: CoreComponentsModule, imports: [CommonModule, WebcamModule, WebcamModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.3.0", ngImport: i0, type: CoreComponentsModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule, WebcamModule],
+                    declarations: [],
+                    exports: [WebcamModule],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tcG9uZW50cy5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtc2NhbmRvYy9zcmMvY29yZS9jb21wb25lbnRzL2NvbXBvbmVudHMubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFFekMsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBRS9DLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQzs7QUFPdEQsTUFBTSxPQUFPLG9CQUFvQjs7aUhBQXBCLG9CQUFvQjtrSEFBcEIsb0JBQW9CLFlBSnJCLFlBQVksRUFBRSxZQUFZLGFBRTFCLFlBQVk7a0hBRVgsb0JBQW9CLFlBSnJCLFlBQVksRUFBRSxZQUFZLEVBRTFCLFlBQVk7MkZBRVgsb0JBQW9CO2tCQUxoQyxRQUFRO21CQUFDO29CQUNSLE9BQU8sRUFBRSxDQUFDLFlBQVksRUFBRSxZQUFZLENBQUM7b0JBQ3JDLFlBQVksRUFBRSxFQUFFO29CQUNoQixPQUFPLEVBQUUsQ0FBQyxZQUFZLENBQUM7aUJBQ3hCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuaW1wb3J0IHsgQ29tbW9uTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcblxuaW1wb3J0IHsgV2ViY2FtTW9kdWxlIH0gZnJvbSAnLi93ZWJjYW0vd2ViY2FtLm1vZHVsZSc7XG5cbkBOZ01vZHVsZSh7XG4gIGltcG9ydHM6IFtDb21tb25Nb2R1bGUsIFdlYmNhbU1vZHVsZV0sXG4gIGRlY2xhcmF0aW9uczogW10sXG4gIGV4cG9ydHM6IFtXZWJjYW1Nb2R1bGVdLFxufSlcbmV4cG9ydCBjbGFzcyBDb3JlQ29tcG9uZW50c01vZHVsZSB7fVxuIl19

package/esm2020/core/components/webcam/domain/webcam-image.mjs

@@ -0,0 +1,58 @@
+/**
+ * Container class for a captured webcam image
+ * @author basst314, davidshen84
+ */
+export class WebcamImage {
+    constructor(imageAsDataUrl, mimeType, imageData, resized) {
+        this._mimeType = mimeType;
+        this._imageAsDataUrl = imageAsDataUrl;
+        this._imageData = imageData;
+        this._imageResized = resized;
+    }
+    /**
+     * Extracts the Base64 data out of the given dataUrl.
+     * @param dataUrl the given dataUrl
+     * @param mimeType the mimeType of the data
+     */
+    static getDataFromDataUrl(dataUrl, mimeType) {
+        return dataUrl.replace(`data:${mimeType};base64,`, '');
+    }
+    /**
+     * Get the base64 encoded image data
+     * @returns base64 data of the image
+     */
+    get imageAsBase64() {
+        return this._imageAsBase64
+            ? this._imageAsBase64
+            : (this._imageAsBase64 = WebcamImage.getDataFromDataUrl(this._imageAsDataUrl, this._mimeType));
+    }
+    /**
+     * Get the encoded image as dataUrl
+     * @returns the dataUrl of the image
+     */
+    get imageAsDataUrl() {
+        return this._imageAsDataUrl;
+    }
+    /**
+     * Get the ImageData object associated with the canvas' 2d context.
+     * @returns the ImageData of the canvas's 2d context.
+     */
+    get imageData() {
+        return this._imageData;
+    }
+    get imageResized() {
+        return this._imageResized;
+    }
+    get dataUrl() {
+        const canvas = document.createElement('canvas');
+        const { width, height } = this._imageData;
+        canvas.width = width;
+        canvas.height = height;
+        const ctx = canvas.getContext('2d');
+        if (ctx) {
+            ctx.putImageData(this._imageData, 0, 0);
+        }
+        return canvas.toDataURL(this._mimeType, 1);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/core/components/webcam/domain/webcam-init-error.mjs

@@ -0,0 +1,3 @@
+export class WebcamInitError {
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2ViY2FtLWluaXQtZXJyb3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtc2NhbmRvYy9zcmMvY29yZS9jb21wb25lbnRzL3dlYmNhbS9kb21haW4vd2ViY2FtLWluaXQtZXJyb3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxPQUFPLGVBQWU7Q0FHM0IiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgY2xhc3MgV2ViY2FtSW5pdEVycm9yIHtcbiAgcHVibGljIG1lc3NhZ2U/OiBzdHJpbmc7XG4gIHB1YmxpYyBtZWRpYVN0cmVhbUVycm9yPzphbnk7XG59XG4iXX0=

package/esm2020/core/components/webcam/domain/webcam-mirror-properties.mjs

@@ -0,0 +1,3 @@
+export class WebcamMirrorProperties {
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2ViY2FtLW1pcnJvci1wcm9wZXJ0aWVzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmd4LXNjYW5kb2Mvc3JjL2NvcmUvY29tcG9uZW50cy93ZWJjYW0vZG9tYWluL3dlYmNhbS1taXJyb3ItcHJvcGVydGllcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLE9BQU8sc0JBQXNCO0NBRWxDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGNsYXNzIFdlYmNhbU1pcnJvclByb3BlcnRpZXMge1xuICBwdWJsaWMgeD86IHN0cmluZzsgIC8vIFtcImF1dG9cIiwgXCJhbHdheXNcIiwgXCJuZXZlclwiXVxufVxuIl19

package/esm2020/core/components/webcam/util/webcam.util.mjs

@@ -0,0 +1,48 @@
+import { from, Observable } from 'rxjs';
+import { switchMap, tap } from 'rxjs/operators';
+export class WebcamUtil {
+    /**
+     * Lists available videoInput devices
+     * @returns a list of media device info.
+     */
+    static getAvailableVideoInputs() {
+        return new Observable((observer) => {
+            if (!navigator.mediaDevices || !navigator.mediaDevices.enumerateDevices) {
+                return observer.error(null);
+            }
+            const _window = window;
+            let streams;
+            from(navigator.mediaDevices.getUserMedia({
+                video: { deviceId: undefined },
+            }))
+                .pipe(tap((s) => { streams = s; }), switchMap((s) => from(navigator.mediaDevices.enumerateDevices())))
+                .subscribe((devices) => {
+                //  console.log(streams);
+                if (streams) {
+                    streams.getTracks().forEach((track) => {
+                        track.stop();
+                    });
+                }
+                observer.next(devices.filter((device) => device.kind === 'videoinput'));
+            });
+        });
+        // return new Promise((resolve, reject) => {
+        //   navigator.mediaDevices.getUserMedia({
+        //     video: undefined,
+        //   });
+        //   navigator.mediaDevices
+        //     .enumerateDevices()
+        //     .then((devices: MediaDeviceInfo[]) => {
+        //       resolve(
+        //         devices.filter(
+        //           (device: MediaDeviceInfo) => device.kind === 'videoinput'
+        //         )
+        //       );
+        //     })
+        //     .catch((err) => {
+        //       reject(err.message || err);
+        //     });
+        // });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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