diginext-utils 1.0.1 → 1.0.5

package/dist/README.md

@@ -0,0 +1,3 @@
+## Support
+
+Liên hệ [TOP GROUP Developers](mailto:dev@wearetopgroup.com) nếu cần hỗ trợ.

package/dist/babel.config.json

@@ -0,0 +1,21 @@
+{
+    "presets": [
+        [
+            "@babel/env",
+            {
+                "targets": {
+                    "edge": "17",
+                    "firefox": "60",
+                    "chrome": "67",
+                    "safari": "11.1"
+                },
+                "useBuiltIns": "usage",
+                "corejs": "3.6.5"
+            }
+        ],
+        "@babel/preset-react"
+    ],
+    "ignore": [
+        "node_modules"
+    ]
+}

package/dist/index.js

@@ -0,0 +1,148 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  Timer: true,
+  requestCamera: true,
+  requestDeviceOrientationControl: true
+};
+Object.defineProperty(exports, "Timer", {
+  enumerable: true,
+  get: function get() {
+    return _Timer.default;
+  }
+});
+Object.defineProperty(exports, "requestCamera", {
+  enumerable: true,
+  get: function get() {
+    return _requestCamera.default;
+  }
+});
+Object.defineProperty(exports, "requestDeviceOrientationControl", {
+  enumerable: true,
+  get: function get() {
+    return _requestDeviceOrientationControl.default;
+  }
+});
+
+var _array = require("./src/array");
+
+Object.keys(_array).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _array[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _array[key];
+    }
+  });
+});
+
+var _device = require("./src/device");
+
+Object.keys(_device).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _device[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _device[key];
+    }
+  });
+});
+
+var _browser = require("./src/device/browser");
+
+Object.keys(_browser).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _browser[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _browser[key];
+    }
+  });
+});
+
+var _camera = require("./src/device/camera");
+
+Object.keys(_camera).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _camera[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _camera[key];
+    }
+  });
+});
+
+var _math = require("./src/math");
+
+Object.keys(_math).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _math[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _math[key];
+    }
+  });
+});
+
+var _object = require("./src/object");
+
+Object.keys(_object).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _object[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _object[key];
+    }
+  });
+});
+
+var _string = require("./src/string");
+
+Object.keys(_string).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _string[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _string[key];
+    }
+  });
+});
+
+var _url = require("./src/string/url");
+
+Object.keys(_url).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _url[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _url[key];
+    }
+  });
+});
+
+var _Timer = _interopRequireDefault(require("./src/Timer"));
+
+var _requestCamera = _interopRequireDefault(require("./src/permission/requestCamera"));
+
+var _requestDeviceOrientationControl = _interopRequireDefault(require("./src/permission/requestDeviceOrientationControl"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

package/dist/package.json

@@ -0,0 +1,34 @@
+{
+	"name": "diginext-utils",
+	"version": "1.0.5",
+	"author": {
+		"name": "TOP GROUP (a.k.a Digitop)",
+		"email": "dev@wearetopgroup.com"
+	},
+	"main": "dist/index.js",
+	"module": "dist/index.js",
+	"files": [
+		"dist",
+		"README.md"
+	],
+	"scripts": {
+		"publish": "npm publish",
+		"clean": "rm -rf .turbo && rm -rf node_modules && rm -rf dist",
+		"build": "rm -rf dist && NODE_ENV=production babel . --out-dir dist --copy-files"
+	},
+	"dependencies": {
+		"@babel/polyfill": "^7.12.1",
+		"@babel/preset-react": "^7.18.6",
+		"@babel/runtime": "^7.18.9",
+		"gsap": "^3.10.4",
+		"lodash": "^4.17.21"
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"devDependencies": {
+		"@babel/cli": "^7.18.10",
+		"@babel/core": "^7.18.10",
+		"@babel/preset-env": "^7.18.10"
+	}
+}

package/dist/src/Camera.js

@@ -0,0 +1,420 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isWebcamSupport = void 0;
+exports.requestWebcam = requestWebcam;
+exports.stopWebcam = stopWebcam;
+exports.webcam = exports.video = void 0;
+
+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 _gsap = _interopRequireDefault(require("gsap"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// check for device orientation support
+var DEVICE_ORIENTATION = {
+  VERTICAL: "vertical",
+  HORIZONTAL: "horizontal"
+};
+var deviceOrientation = DEVICE_ORIENTATION.VERTICAL;
+var video;
+/**
+ * @type {AppWebcam}
+ */
+
+exports.video = video;
+var webcam;
+exports.webcam = webcam;
+var isWebcamSupport = false; // var onSetupComplete;
+
+exports.isWebcamSupport = isWebcamSupport;
+
+function requestWebcam(_ref) {
+  let {
+    container,
+    onRejected,
+    onReady
+  } = _ref;
+  // options = options || {};
+  var 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);
+
+  _gsap.default.set(video, {
+    opacity: 1
+  }); // $(video).css("z-index", "-2");
+  // $(video).css("position", "absolute");
+  // $(video).css("top", "0px");
+  // $(video).css("left", "0px");
+
+
+  stopWebcam();
+  exports.webcam = webcam = new AppWebcam(video);
+
+  webcam.onReady = function (e) {
+    setupApp();
+    exports.isWebcamSupport = isWebcamSupport = true;
+    if (onReady) onReady(e);
+  };
+
+  webcam.onRejected = function (e) {
+    setupApp();
+    exports.isWebcamSupport = isWebcamSupport = false; // if (typeof gaTrackingClick != "undefined") gaTrackingClick('request_permission', 'reject_camera');
+
+    if (onRejected) onRejected(e);
+  };
+
+  return webcam;
+}
+
+function setupApp() {
+  var _isAllow = false;
+
+  if (typeof webcam != "undefined") {
+    if (webcam.isAllowed) {
+      _gsap.default.to(video, {
+        duration: 2,
+        opacity: 1
+      });
+
+      _isAllow = true;
+    }
+  }
+}
+
+function stopWebcam() {
+  if (webcam) webcam.remove();
+}
+/**
+ * @param  {HTMLVideoElement} videoElement
+ */
+
+
+function AppWebcam(videoElement) {
+  // define scope
+  var scope = this; // private vars
+
+  /**
+   * @type {MediaDeviceInfo[]}
+   */
+
+  var inputCameras = [];
+  /**
+   * @type {MediaStreamConstraints}
+   */
+
+  var requestedMediaConstraints = {
+    video: {
+      // width: 640,
+      // height: 480,
+      facingMode: {
+        exact: "environment"
+      } // facingMode: 'environment'
+
+    },
+    audio: false
+  };
+  /**
+   * @type {MediaStream}
+   */
+
+  var stream;
+  var isAllowed = false;
+  /**
+   * @type {HTMLVideoElement}
+   */
+
+  var video;
+  var canvas = document.createElement("canvas");
+  canvas.setAttribute("id", "AppWebcam" + new Date().getTime()); // var requestWidth = deviceOrientation == DEVICE_ORIENTATION.VERTICAL
+  //   ? 360
+  //   : 640;
+  // var requestHeight = deviceOrientation == DEVICE_ORIENTATION.VERTICAL
+  //   ? 640
+  //   : 360;
+
+  this.currentCamera = null; // initialise
+
+  init(); // constructor
+
+  function init() {
+    if (!videoElement) {
+      video = document.createElement("video");
+    } else {
+      video = videoElement;
+    } //alert("!");
+    // canvasElement = document.getElementById ('canvas');
+    // canvasElement.width = window.innerWidth - 50;
+    // canvasElement.height = canvasElement.width;
+    // canvas = canvasElement.getContext ('2d');
+    // loadingMessage = document.getElementById ('loadingMessage');
+    // Older browsers might not implement mediaDevices at all, so we set an empty object first
+
+
+    if (navigator.mediaDevices === undefined) {
+      navigator.mediaDevices = {};
+    } // Some browsers partially implement mediaDevices. We can't just assign an object
+    // with getUserMedia as it would overwrite existing properties.
+    // Here, we will just add the getUserMedia property if it's missing.
+
+
+    if (navigator.mediaDevices.getUserMedia === undefined) {
+      navigator.mediaDevices.getUserMedia = function (constraints) {
+        // First get ahold of the legacy getUserMedia, if present
+        var getUserMedia = navigator.webkitGetUserMedia || navigator.mozGetUserMedia; // Some browsers just don't implement it - return a rejected promise with an error
+        // to keep a consistent interface
+
+        if (!getUserMedia) {
+          return Promise.reject(new Error("getUserMedia is not implemented in this browser"));
+        } // Otherwise, wrap the call to the old navigator.getUserMedia with a Promise
+
+
+        return new Promise(function (resolve, reject) {
+          getUserMedia.call(navigator, constraints, resolve, reject);
+        });
+      };
+    } // 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);
+    } // navigator.mediaDevices.getUserMedia(requestedMediaConstraints).then(() => {
+    //   if (typeof navigator.mediaDevices.enumerateDevices == "undefined") {
+    //     setTimeout(function () {
+    //       handleError({ name: 'Error', message: 'NotSupported' });
+    //     }, 50);
+    //   } else {
+    //     navigator.mediaDevices
+    //       .enumerateDevices()
+    //       .then(parseDevices)
+    //       .catch(handleError);
+    //   }
+    // }).catch(handleError);
+
+  }
+  /**
+   * @param  {MediaDeviceInfo[]} devices
+   */
+
+
+  function parseDevices(devices) {
+    inputCameras = [];
+    var 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) {
+      var cams = "";
+      var backCamera;
+      inputCameras.map((cam, index) => {
+        cams += "[".concat(cam.deviceId, "] ").concat(cam.kind, " | ").concat(cam.label, "\n"); // console.log(cam);
+
+        var 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));
+      scope.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();
+    }
+  }
+
+  function getStreamOfCameraId(id) {
+    var constraints = {
+      video: {
+        deviceId: {
+          exact: id
+        }
+      },
+      audio: false
+    };
+    return new Promise((resolve, reject) => {
+      navigator.mediaDevices.getUserMedia(constraints).then(resolve).catch(reject);
+    });
+  }
+  /**
+   * @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);
+      if (scope.onRejected != null) scope.onRejected(e);
+    });
+    video.addEventListener("loadedmetadata", function (e) {
+      canvas.width = video.videoWidth;
+      canvas.height = video.videoHeight;
+      canvas.style.width = window.outerWidth + "px";
+      canvas.style.height = window.outerHeight + "px";
+
+      if (scope.currentCamera.label.toLowerCase().indexOf("facetime") > -1) {
+        video.style.transform = "scaleX(-1)";
+        video.style.webkitTransform = "scaleX(-1)";
+      }
+
+      video.play();
+      if (scope.onReady) scope.onReady(video);
+    });
+  }
+
+  function handleError(err) {
+    console.error(err);
+    var errMsg = "[Camera.js] " + err.name + ": " + err.message;
+    console.error(errMsg);
+    isAllowed = false;
+    if (scope.onRejected != null) scope.onRejected(err);
+  }
+
+  function drawVideo() {
+    var ctx = canvas.getContext("2d");
+    canvas.width = video.videoWidth;
+    canvas.height = video.videoHeight;
+    ctx.drawImage(video, 0, 0, video.videoWidth, video.videoHeight);
+  }
+
+  function captureAsBase64(callback) {
+    console.log("[Camera.js] Base64 captured -> ".concat(video.videoWidth, "x").concat(video.videoHeight));
+    drawVideo();
+    TweenMax.delayedCall(0.2, function () {
+      var screenshot = canvas.toDataURL("image/png");
+      if (callback) callback(screenshot);
+    });
+  }
+
+  function captureAsImageData() {
+    drawVideo();
+    var ctx = canvas.getContext("2d");
+    return ctx.getImageData(0, 0, video.videoWidth, video.videoHeight);
+  }
+
+  function dispose() {}
+
+  function enable() {}
+
+  function disable() {}
+
+  function remove() {
+    if (stream) stream.getTracks().forEach(track => track.stop());
+  } // exports
+
+
+  this.enable = enable;
+  this.disable = disable;
+  this.video = video;
+  this.inputCameras = inputCameras;
+  this.canvas = canvas;
+  this.captureAsBase64 = captureAsBase64;
+  this.captureAsImageData = captureAsImageData;
+  this.onReady = null;
+  this.onRejected = null;
+  this.onGotDevices = null;
+  this.onGotDevicesFailed = null;
+  this.init = init;
+  this.remove = remove;
+  this.stream = stream;
+}

package/dist/src/Checker.js

@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isJSON = void 0;
+
+require("core-js/modules/es.json.stringify.js");
+
+const isJSON = content => {
+  if (typeof content == "object") {
+    try {
+      content = JSON.stringify(content);
+    } catch (err) {
+      return false;
+    }
+  }
+
+  if (typeof content == "string") {
+    try {
+      content = JSON.parse(content);
+    } catch (err) {
+      return false;
+    }
+  }
+
+  if (typeof content != "object") {
+    return false;
+  }
+
+  return true;
+};
+
+exports.isJSON = isJSON;