diginext-utils 1.0.2 → 1.0.3

package/dist/device/camera.js

@@ -0,0 +1,238 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getWebcam = getWebcam;
+
+require("core-js/modules/es.promise.js");
+
+require("core-js/modules/es.json.stringify.js");
+
+require("core-js/modules/web.dom-collections.iterator.js");
+
+require("core-js/modules/web.url.js");
+
+require("core-js/modules/web.url-search-params.js");
+
+var _requestCamera = _interopRequireDefault(require("../permission/requestCamera"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ *
+ * @param {{
+ * container,
+ * facingMode : environment | user,
+ * audio : boolean,
+ * }} param0
+ * @returns
+ */
+function getWebcam(_ref) {
+  let {
+    //
+    container,
+    facingMode = "environment",
+    audio = false
+  } = _ref;
+  if (typeof window == "undefined") return;
+  container = container || document.body;
+  return new Promise(async (resolve, reject) => {
+    const video = document.createElement("video");
+    video.style.position = "absolute";
+    video.style.top = 0;
+    video.style.left = 0;
+    video.style.width = "100%";
+    video.style.height = "100%";
+    container.append(video);
+    let inputCameras = [];
+    let currentCamera;
+    /**
+     * @type {MediaStreamConstraints}
+     */
+
+    const requestedMediaConstraints = {
+      video: {
+        facingMode: {
+          exact: facingMode
+        }
+      },
+      audio
+    };
+    /**
+     * @type {MediaStream}
+     */
+
+    let stream;
+    let isAllowed = false;
+    console.log("[Camera.js] Requesting:", requestedMediaConstraints);
+    const res = await (0, _requestCamera.default)({
+      audio
+    });
+
+    if (!res) {
+      setTimeout(function () {
+        handleError({
+          name: "Error",
+          message: "NotSupported"
+        });
+      }, 50);
+    } // start requesting media permissions:
+    // console.log("[Camera.js] Requesting:", requestedMediaConstraints);
+    // if (navigator.mediaDevices.enumerateDevices === undefined) {
+    // 	setTimeout(function () {
+    // 		handleError({ name: "Error", message: "NotSupported" });
+    // 	}, 50);
+    // } else {
+
+
+    navigator.mediaDevices.enumerateDevices().then(parseDevices).catch(handleError); // }
+
+    /**
+     * @param  {MediaDeviceInfo[]} devices
+     */
+
+    function parseDevices(devices) {
+      inputCameras = [];
+      let backCameras = [];
+      devices.forEach(function (device) {
+        if (device.kind == "videoinput" && typeof device.deviceId != "undefined" && device.deviceId != "") {
+          inputCameras.push(device);
+        }
+      }); // //alert (JSON.stringify (devices));
+
+      console.log("[Camera.js] inputCameras:", inputCameras);
+
+      if (inputCameras.length > 0) {
+        let cams = "";
+        let backCamera;
+        inputCameras.map((cam, index) => {
+          cams += "[".concat(cam.deviceId, "] ").concat(cam.kind, " | ").concat(cam.label, "\n"); // console.log(cam);
+
+          let label = cam.label.toLowerCase();
+
+          if (label.indexOf("back") > -1 || label.indexOf("facetime") > -1) {
+            backCamera = cam;
+            backCameras.push(backCamera);
+          }
+        });
+
+        if (backCameras.length > 1) {
+          backCamera = backCameras[backCameras.length - 1];
+        }
+
+        console.log("[Camera.js] All input sources:", cams);
+        console.log("[Camera.js] This device has ".concat(backCameras.length, " back camera").concat(backCameras.length > 1 ? "s" : "", "."));
+        console.log("[Camera.js] backCameras:", JSON.stringify(backCameras));
+        currentCamera = backCamera;
+
+        if (scope.onGotDevices) {
+          scope.onGotDevices(devices);
+        } // Lấy stream của camera sau
+        // (Lấy cái cuối cùng trong danh sách trước, thường sẽ là camera chính trên Android)
+
+
+        getStreamOfCameraId(backCamera.deviceId).then(onStreamReceived).catch(e => {
+          if (backCameras.length > 1) {
+            // nếu thiết bị có nhiều hơn 1 camera sau -> thử lấy camera khác
+            backCamera = backCameras[backCameras.length - 2];
+            getStreamOfCameraId(backCamera.deviceId).then(onStreamReceived).catch(handleError);
+          } else if (backCameras.length > 2) {
+            // nếu thiết bị có nhiều hơn 2 camera sau -> thử lấy camera khác nữa
+            backCamera = backCameras[backCameras.length - 3];
+            getStreamOfCameraId(backCamera.deviceId).then(onStreamReceived).catch(handleError);
+          } else {
+            // nếu thiết bị đéo có camera sau...
+            handleError(e);
+          }
+        });
+      } else {
+        navigator.mediaDevices.getUserMedia(requestedMediaConstraints).then(onStreamReceived).catch(handleError); // if (scope.onGotDevicesFailed) scope.onGotDevicesFailed();
+      }
+    }
+    /**
+     * @param  {MediaStream} stream
+     */
+
+
+    function onStreamReceived(stream) {
+      if (inputCameras.length == 0) {
+        console.log("[Camera.js] Not found any back cameras, request again?");
+        navigator.mediaDevices.enumerateDevices().then(parseDevices).catch(handleError);
+        return;
+      }
+
+      isAllowed = true;
+      playWebcamVideo(stream);
+    }
+    /**
+     * @param  {MediaStream} _stream
+     */
+
+
+    function playWebcamVideo(_stream) {
+      stream = _stream;
+
+      if ("srcObject" in video) {
+        // //alert ('GOT STREAM VIDEO OBJECT');
+        video.srcObject = _stream;
+      } else {
+        // //alert ('GOT STREAM VIDEO SOURCE URL');
+        // Avoid using this in new browsers, as it is going away.
+        video.src = window.URL.createObjectURL(_stream);
+      } // required to tell iOS safari we don't want fullscreen
+
+
+      video.setAttribute("playsinline", true);
+      video.setAttribute("muted", true);
+      video.setAttribute("autoplay", true);
+      video.muted = true;
+      video.autoplay = true;
+      video.style.objectFit = "cover";
+      video.play(); // auto play
+
+      video.addEventListener("canplay", function (e) {// //alert ('CAN PLAY');
+      });
+      video.addEventListener("canplaythrough", function (e) {// //alert ('CAN PLAY THROUGH');
+      });
+      video.addEventListener("error", e => console.log("[Camera.js] <video> error:", e));
+      video.addEventListener("stalled", function (e) {
+        // //alert ('CANNOT GET METADATA');
+        isAllowed = false;
+        console.log("[Camera.js] <video> stalled:", e);
+        reject();
+      });
+      video.addEventListener("loadedmetadata", function (e) {
+        if (currentCamera.label.toLowerCase().indexOf("facetime") > -1) {
+          video.style.transform = "scaleX(-1)";
+          video.style.webkitTransform = "scaleX(-1)";
+        }
+
+        video.play();
+        resolve(video);
+      });
+    }
+
+    function getStreamOfCameraId(id) {
+      const constraints = {
+        video: {
+          deviceId: {
+            exact: id
+          }
+        },
+        audio: false
+      };
+      return new Promise((resolve, reject) => {
+        navigator.mediaDevices.getUserMedia(constraints).then(resolve).catch(reject);
+      });
+    }
+
+    function handleError(err) {
+      console.error(err);
+      const errMsg = "[Camera.js] " + err.name + ": " + err.message;
+      console.error(errMsg);
+      isAllowed = false;
+      reject();
+    }
+  });
+}

package/dist/device/index.js

@@ -0,0 +1,304 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isMobile = exports.isIos = exports.isAndroid = exports.checkOS = void 0;
+
+require("core-js/modules/es.regexp.exec.js");
+
+require("core-js/modules/es.string.match.js");
+
+require("core-js/modules/es.parse-float.js");
+
+require("core-js/modules/es.parse-int.js");
+
+require("core-js/modules/es.regexp.test.js");
+
+const isIos = () => {
+  const deviceInfo = checkOS();
+  if (deviceInfo) return deviceInfo.os.toLowerCase() == "ios";
+  console.log("Can't check OS");
+  return null;
+};
+
+exports.isIos = isIos;
+
+const isAndroid = () => {
+  const deviceInfo = checkOS();
+  if (deviceInfo) return deviceInfo.os.toLowerCase() == "android";
+  console.log("Can't check OS");
+  return null;
+};
+
+exports.isAndroid = isAndroid;
+
+const isMobile = () => {
+  if (typeof navigator == "undefined") return null;
+
+  if (navigator.userAgent.match(/Android/i) || navigator.userAgent.match(/webOS/i) || navigator.userAgent.match(/iPhone/i) || navigator.userAgent.match(/iPad/i) || navigator.userAgent.match(/iPod/i) || navigator.userAgent.match(/BlackBerry/i) || navigator.userAgent.match(/Windows Phone/i)) {
+    return true;
+  } else {
+    return false;
+  }
+};
+/**
+ *
+ * @returns {{
+ * screen,
+ * browser,
+ * browserVersion,
+ * browserMajorVersion,
+ * mobile,
+ * os,
+ * osVersion,
+ * cookies,
+ * flashVersion,
+ * }}
+ */
+
+
+exports.isMobile = isMobile;
+
+const checkOS = () => {
+  var _window;
+
+  if (typeof window == "undefined") return {};
+
+  if (typeof ((_window = window) === null || _window === void 0 ? void 0 : _window.deviceInfo) == "undefined") {
+    var unknown = "-"; // screen
+
+    var screenSize = "";
+
+    if (screen.width) {
+      var width = screen.width ? screen.width : "";
+      var height = screen.height ? screen.height : "";
+      screenSize += "" + width + " x " + height;
+    } // browser
+
+
+    var nVer = navigator.appVersion;
+    var nAgt = navigator.userAgent;
+    var browser = navigator.appName;
+    var version = "" + parseFloat(navigator.appVersion);
+    var majorVersion = parseInt(navigator.appVersion, 10);
+    var nameOffset, verOffset, ix; // Opera
+
+    if ((verOffset = nAgt.indexOf("Opera")) != -1) {
+      browser = "Opera";
+      version = nAgt.substring(verOffset + 6);
+
+      if ((verOffset = nAgt.indexOf("Version")) != -1) {
+        version = nAgt.substring(verOffset + 8);
+      }
+    } // Opera Next
+
+
+    if ((verOffset = nAgt.indexOf("OPR")) != -1) {
+      browser = "Opera";
+      version = nAgt.substring(verOffset + 4);
+    } // Edge
+    else if ((verOffset = nAgt.indexOf("Edge")) != -1) {
+      browser = "Microsoft Edge";
+      version = nAgt.substring(verOffset + 5);
+    } // MSIE
+    else if ((verOffset = nAgt.indexOf("MSIE")) != -1) {
+      browser = "Microsoft Internet Explorer";
+      version = nAgt.substring(verOffset + 5);
+    } // Chrome
+    else if ((verOffset = nAgt.indexOf("Chrome")) != -1) {
+      browser = "Chrome";
+      version = nAgt.substring(verOffset + 7);
+    } // Safari
+    else if ((verOffset = nAgt.indexOf("Safari")) != -1) {
+      browser = "Safari";
+      version = nAgt.substring(verOffset + 7);
+
+      if ((verOffset = nAgt.indexOf("Version")) != -1) {
+        version = nAgt.substring(verOffset + 8);
+      }
+    } // Firefox
+    else if ((verOffset = nAgt.indexOf("Firefox")) != -1) {
+      browser = "Firefox";
+      version = nAgt.substring(verOffset + 8);
+    } // MSIE 11+
+    else if (nAgt.indexOf("Trident/") != -1) {
+      browser = "Microsoft Internet Explorer";
+      version = nAgt.substring(nAgt.indexOf("rv:") + 3);
+    } // Other browsers
+    else if ((nameOffset = nAgt.lastIndexOf(" ") + 1) < (verOffset = nAgt.lastIndexOf("/"))) {
+      browser = nAgt.substring(nameOffset, verOffset);
+      version = nAgt.substring(verOffset + 1);
+
+      if (browser.toLowerCase() == browser.toUpperCase()) {
+        browser = navigator.appName;
+      }
+    } // trim the version string
+
+
+    if ((ix = version.indexOf(";")) != -1) version = version.substring(0, ix);
+    if ((ix = version.indexOf(" ")) != -1) version = version.substring(0, ix);
+    if ((ix = version.indexOf(")")) != -1) version = version.substring(0, ix);
+    majorVersion = parseInt("" + version, 10);
+
+    if (isNaN(majorVersion)) {
+      version = "" + parseFloat(navigator.appVersion);
+      majorVersion = parseInt(navigator.appVersion, 10);
+    } // mobile version
+
+
+    var mobile = /Mobile|mini|Fennec|Android|iP(ad|od|hone)/.test(nVer); // cookie
+
+    var cookieEnabled = navigator.cookieEnabled ? true : false;
+
+    if (typeof navigator.cookieEnabled == "undefined" && !cookieEnabled) {
+      document.cookie = "testcookie";
+      cookieEnabled = document.cookie.indexOf("testcookie") != -1 ? true : false;
+    } // system
+
+
+    var os = unknown;
+    var clientStrings = [{
+      s: "Windows 10",
+      r: /(Windows 10.0|Windows NT 10.0)/
+    }, {
+      s: "Windows 8.1",
+      r: /(Windows 8.1|Windows NT 6.3)/
+    }, {
+      s: "Windows 8",
+      r: /(Windows 8|Windows NT 6.2)/
+    }, {
+      s: "Windows 7",
+      r: /(Windows 7|Windows NT 6.1)/
+    }, {
+      s: "Windows Vista",
+      r: /Windows NT 6.0/
+    }, {
+      s: "Windows Server 2003",
+      r: /Windows NT 5.2/
+    }, {
+      s: "Windows XP",
+      r: /(Windows NT 5.1|Windows XP)/
+    }, {
+      s: "Windows 2000",
+      r: /(Windows NT 5.0|Windows 2000)/
+    }, {
+      s: "Windows ME",
+      r: /(Win 9x 4.90|Windows ME)/
+    }, {
+      s: "Windows 98",
+      r: /(Windows 98|Win98)/
+    }, {
+      s: "Windows 95",
+      r: /(Windows 95|Win95|Windows_95)/
+    }, {
+      s: "Windows NT 4.0",
+      r: /(Windows NT 4.0|WinNT4.0|WinNT|Windows NT)/
+    }, {
+      s: "Windows CE",
+      r: /Windows CE/
+    }, {
+      s: "Windows 3.11",
+      r: /Win16/
+    }, {
+      s: "Android",
+      r: /Android/
+    }, {
+      s: "Open BSD",
+      r: /OpenBSD/
+    }, {
+      s: "Sun OS",
+      r: /SunOS/
+    }, {
+      s: "Linux",
+      r: /(Linux|X11)/
+    }, {
+      s: "iOS",
+      r: /(iPhone|iPad|iPod)/
+    }, {
+      s: "Mac OS X",
+      r: /Mac OS X/
+    }, {
+      s: "Mac OS",
+      r: /(MacPPC|MacIntel|Mac_PowerPC|Macintosh)/
+    }, {
+      s: "QNX",
+      r: /QNX/
+    }, {
+      s: "UNIX",
+      r: /UNIX/
+    }, {
+      s: "BeOS",
+      r: /BeOS/
+    }, {
+      s: "OS/2",
+      r: /OS\/2/
+    }, {
+      s: "Search Bot",
+      r: /(nuhk|Googlebot|Yammybot|Openbot|Slurp|MSNBot|Ask Jeeves\/Teoma|ia_archiver)/
+    }];
+
+    for (var id in clientStrings) {
+      var cs = clientStrings[id];
+
+      if (cs.r.test(nAgt)) {
+        os = cs.s;
+        break;
+      }
+    }
+
+    var osVersion = unknown;
+
+    if (/Windows/.test(os)) {
+      osVersion = /Windows (.*)/.exec(os)[1];
+      os = "Windows";
+    }
+
+    switch (os) {
+      case "Mac OS X":
+        osVersion = /Mac OS X (10[\.\_\d]+)/.exec(nAgt)[1];
+        break;
+
+      case "Android":
+        osVersion = /Android ([\.\_\d]+)/.exec(nAgt)[1];
+        break;
+
+      case "iOS":
+        osVersion = /OS (\d+)_(\d+)_?(\d+)?/.exec(nVer);
+        osVersion = osVersion[1] + "." + osVersion[2] + "." + (osVersion[3] | 0);
+        break;
+    } // flash (you'll need to include swfobject)
+
+    /* script src="//ajax.googleapis.com/ajax/libs/swfobject/2.2/swfobject.js" */
+
+
+    var flashVersion = "no check";
+
+    if (typeof swfobject != "undefined") {
+      var fv = swfobject.getFlashPlayerVersion();
+
+      if (fv.major > 0) {
+        flashVersion = fv.major + "." + fv.minor + " r" + fv.release;
+      } else {
+        flashVersion = unknown;
+      }
+    }
+
+    const deviceInfo = {
+      screen: screenSize,
+      browser: browser,
+      browserVersion: version,
+      browserMajorVersion: majorVersion,
+      mobile: mobile,
+      os: os,
+      osVersion: osVersion,
+      cookies: cookieEnabled,
+      flashVersion: flashVersion
+    };
+    window.deviceInfo = deviceInfo;
+  }
+
+  return window.deviceInfo;
+};
+
+exports.checkOS = checkOS;