diginext-utils 1.0.1 → 1.0.5

package/{src → dist/src}/math/index.js

@@ -1,38 +1,52 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.randRound = exports.randInt = exports.randHalt = exports.randFloat = exports.rand = exports.radToDeg = exports.degToRad = void 0;
 const DEG2RAD = Math.PI / 180;
 const RAD2DEG = 180 / Math.PI;
-
 /**
  *
  * @param {Number} number
  * @return {Number}
  */
-export const randRound = (number) => {
-	return Math.round(Math.random() * number);
-};
 
+const randRound = number => {
+  return Math.round(Math.random() * number);
+};
 /**
  *
  * @param {Number} number
  * @return {Number}
  */
-export const rand = (number) => {
-	return (Math.random() - Math.random()) * number;
-};
 
+
+exports.randRound = randRound;
+
+const rand = number => {
+  return (Math.random() - Math.random()) * number;
+};
 /**
  *
  * @param {Number} number
  * @return {Number}
  */
-export const randHalt = (number) => {
-	var rand = Math.random() - Math.random();
-	var res;
-	if (rand > 0) {
-		res = rand * (number / 2) + number / 2;
-	} else {
-		res = rand * (number / 2) - number / 2;
-	}
-	return Math.abs(res);
+
+
+exports.rand = rand;
+
+const randHalt = number => {
+  var rand = Math.random() - Math.random();
+  var res;
+
+  if (rand > 0) {
+    res = rand * (number / 2) + number / 2;
+  } else {
+    res = rand * (number / 2) - number / 2;
+  }
+
+  return Math.abs(res);
 };
 /**
  *
@@ -40,48 +54,58 @@ export const randHalt = (number) => {
  * @param {Number} high
  * @return {Number}
  */
-export const randInt = (low, high) => {
-	return low + Math.floor(Math.random() * (high - low + 1));
-};
 
+
+exports.randHalt = randHalt;
+
+const randInt = (low, high) => {
+  return low + Math.floor(Math.random() * (high - low + 1));
+};
 /**
  *
  * @param {Number} low
  * @param {Number} high
  * @return {Number}
  */
-export const randFloat = (low, high) => {
-	return low + Math.random() * (high - low);
+
+
+exports.randInt = randInt;
+
+const randFloat = (low, high) => {
+  return low + Math.random() * (high - low);
 };
 /**
  *
  * @param {Number} degrees
  * @return {Number}
  */
-export const degToRad = (degrees) => {
-	return degrees * DEG2RAD;
-};
 
+
+exports.randFloat = randFloat;
+
+const degToRad = degrees => {
+  return degrees * DEG2RAD;
+};
 /**
  *
  * @param {Number} degrees
  * @return {Number}
  */
-export const radToDeg = (radians) => {
-	return radians * RAD2DEG;
-};
 
-// const MathExtra = {
+
+exports.degToRad = degToRad;
+
+const radToDeg = radians => {
+  return radians * RAD2DEG;
+}; // const MathExtra = {
 //     isRotateLeft(a, b, c) {
 //         return (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x) > 0;
 //     },
-
 //     deg_between_points_360(cx, cy, ex, ey) {
 //         var theta = this.angleLine(cx, cy, ex, ey); // range (-180, 180]
 //         if (theta < 0) theta = 360 + theta; // range [0, 360)
 //         return theta;
 //     },
-
 //     deg_between_points(cx, cy, ex, ey) {
 //         var dy = ey - cy;
 //         var dx = ex - cx;
@@ -89,7 +113,6 @@ export const radToDeg = (radians) => {
 //         theta *= 180 / Math.PI; // rads to degs, range (-180, 180]
 //         return theta;
 //     },
-
 //     angle_between_points(cx, cy, ex, ey) {
 //         var dy = ey - cy;
 //         var dx = ex - cx;
@@ -97,63 +120,44 @@ export const radToDeg = (radians) => {
 //         // theta *= 180 / Math.PI; // rads to degs, range (-180, 180]
 //         return theta;
 //     },
-
 //     distance2Point(x1, y1, x2, y2) {
 //         var dist = Math.sqrt(Math.pow(x1 - x2, 2) + Math.pow(y1 - y2, 2));
 //         return dist;
 //     },
-
 //     clamp(value, min, max) {
 //         return Math.max(min, Math.min(max, value));
 //     },
-
 //     // compute euclidian modulo of m % n
 //     // https://en.wikipedia.org/wiki/Modulo_operation
-
 //     euclideanModulo(n, m) {
 //         return ((n % m) + m) % m;
 //     },
-
 //     // Linear mapping from range <a1, a2> to range <b1, b2>
-
 //     mapLinear(x, a1, a2, b1, b2) {
 //         return b1 + ((x - a1) * (b2 - b1)) / (a2 - a1);
 //     },
-
 //     // https://en.wikipedia.org/wiki/Linear_interpolation
-
 //     lerp(x, y, t) {
 //         return (1 - t) * x + t * y;
 //     },
-
 //     // http://en.wikipedia.org/wiki/Smoothstep
-
 //     smoothstep(x, min, max) {
 //         if (x <= min) return 0;
 //         if (x >= max) return 1;
-
 //         x = (x - min) / (max - min);
-
 //         return x * x * (3 - 2 * x);
 //     },
-
 //     smootherstep(x, min, max) {
 //         if (x <= min) return 0;
 //         if (x >= max) return 1;
-
 //         x = (x - min) / (max - min);
-
 //         return x * x * x * (x * (x * 6 - 15) + 10);
 //     },
-
 //     // Random integer from <low, high> interval
-
 //     // Random float from <-range/2, range/2> interval
-
 //     randFloatSpread(range) {
 //         return range * (0.5 - Math.random());
 //     },
-
 //     rotationDegToRad(rotation) {
 //         return {
 //             x: this.degToRad(rotation.x),
@@ -161,19 +165,15 @@ export const radToDeg = (radians) => {
 //             z: this.degToRad(rotation.z),
 //         };
 //     },
-
 //     radToDeg(radians) {
 //         return radians * RAD2DEG;
 //     },
-
 //     isPowerOfTwo(value) {
 //         return (value & (value - 1)) === 0 && value !== 0;
 //     },
-
 //     nearestPowerOfTwo(value) {
 //         return Math.pow(2, Math.round(Math.log(value) / Math.LN2));
 //     },
-
 //     nextPowerOfTwo(value) {
 //         value--;
 //         value |= value >> 1;
@@ -182,18 +182,14 @@ export const radToDeg = (radians) => {
 //         value |= value >> 8;
 //         value |= value >> 16;
 //         value++;
-
 //         return value;
 //     },
-
 //     circleByPercentRadius(percent, radius) {
 //         const theta = ((percent * 360 - 90) * Math.PI) / 180;
-
 //         const x = radius * Math.cos(theta);
 //         const y = -radius * Math.sin(theta);
 //         return { x, y };
 //     },
-
 //     /**
 //      *
 //      * @param {Array} array
@@ -207,5 +203,7 @@ export const radToDeg = (radians) => {
 //         return result;
 //     },
 // };
-
 // export default MathExtra;
+
+
+exports.radToDeg = radToDeg;

package/dist/src/object/index.js

@@ -0,0 +1,65 @@
+"use strict";
+
+require("core-js/modules/es.promise.js");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.toInt = exports.toFloat = exports.toBool = exports.toArray = exports.isNull = void 0;
+
+require("core-js/modules/es.regexp.to-string.js");
+
+require("core-js/modules/es.parse-int.js");
+
+require("core-js/modules/es.parse-float.js");
+
+const isNull = object => {
+  if (typeof object == "undefined") return true;
+  if (object == "") return true;
+  if (Array.isArray(object)) return object.length == 0;
+  return object == null;
+};
+
+exports.isNull = isNull;
+
+const toBool = object => {
+  if (isNull(object)) return false;
+  object = object.toString();
+  return object === "true" || object == "1";
+};
+
+exports.toBool = toBool;
+
+const toInt = object => {
+  if (isNull(object)) return 0;
+  object = object.toString();
+  return parseInt(object, 10);
+};
+
+exports.toInt = toInt;
+
+const toFloat = object => {
+  if (isNull(object)) return 0;
+  object = object.toString();
+  return parseFloat(object);
+};
+/**
+ * Convert value in object to array
+ * @param {object} obj
+ * @returns {Array}
+ */
+
+
+exports.toFloat = toFloat;
+
+const toArray = obj => {
+  const array = [];
+
+  for (const key in obj) {
+    array.push(obj[key]);
+  }
+
+  return array;
+};
+
+exports.toArray = toArray;

package/dist/src/permission/requestCamera.js

@@ -0,0 +1,55 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+require("core-js/modules/es.promise.js");
+
+const requestCamera = _ref => {
+  let {
+    audio = true,
+    video = true
+  } = _ref;
+  if (typeof window == "undefined") return false;
+  return new Promise((resolve, reject) => {
+    // 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);
+        });
+      };
+    }
+
+    navigator.mediaDevices.getUserMedia({
+      audio,
+      video
+    }).then(function (stream) {
+      resolve(true);
+    }).catch(function (err) {
+      console.log(err.name + ": " + err.message);
+      resolve(false);
+    });
+  });
+};
+
+var _default = requestCamera;
+exports.default = _default;

package/dist/src/permission/requestDeviceOrientationControl.js

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+require("core-js/modules/es.promise.js");
+
+var _device = require("../device");
+
+const requestDeviceOrientationControl = () => {
+  if (typeof window == "undefined") return false;
+  return new Promise((resolve, reject) => {
+    if ((0, _device.isAndroid)()) resolve(true);
+
+    if (typeof DeviceMotionEvent != "undefined" && DeviceMotionEvent.requestPermission) {
+      // (optional) Do something before API request prompt.
+      DeviceOrientationEvent.requestPermission().then(response => {
+        // (optional) Do something after API prompt dismissed.
+        if (response == "granted") {
+          resolve(true); // resolve({ status: true })
+        } else {
+          resolve(false); // resolve({ status: false, reason: "DeviceMotionEvent is not support" })
+        }
+      }).catch(response => {
+        resolve(false); // resolve({ status: false, reason: response })
+      });
+    } else {
+      resolve(false); // resolve({ status: false, reason: "DeviceMotionEvent is not defined" })
+    }
+  });
+};
+
+var _default = requestDeviceOrientationControl;
+exports.default = _default;