diginext-utils 1.0.2 → 1.0.3

package/dist/math/index.js

@@ -0,0 +1,209 @@
+"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}
+ */
+
+const randRound = number => {
+  return Math.round(Math.random() * number);
+};
+/**
+ *
+ * @param {Number} number
+ * @return {Number}
+ */
+
+
+exports.randRound = randRound;
+
+const rand = number => {
+  return (Math.random() - Math.random()) * number;
+};
+/**
+ *
+ * @param {Number} number
+ * @return {Number}
+ */
+
+
+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);
+};
+/**
+ *
+ * @param {Number} low
+ * @param {Number} high
+ * @return {Number}
+ */
+
+
+exports.randHalt = randHalt;
+
+const randInt = (low, high) => {
+  return low + Math.floor(Math.random() * (high - low + 1));
+};
+/**
+ *
+ * @param {Number} low
+ * @param {Number} high
+ * @return {Number}
+ */
+
+
+exports.randInt = randInt;
+
+const randFloat = (low, high) => {
+  return low + Math.random() * (high - low);
+};
+/**
+ *
+ * @param {Number} degrees
+ * @return {Number}
+ */
+
+
+exports.randFloat = randFloat;
+
+const degToRad = degrees => {
+  return degrees * DEG2RAD;
+};
+/**
+ *
+ * @param {Number} degrees
+ * @return {Number}
+ */
+
+
+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;
+//         var theta = Math.atan2(dy, dx); // range (-PI, PI]
+//         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;
+//         var theta = Math.atan2(dy, dx); // range (-PI, PI]
+//         // 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),
+//             y: this.degToRad(rotation.y),
+//             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;
+//         value |= value >> 2;
+//         value |= value >> 4;
+//         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
+//      */
+//     arrayToVector(array = [0, 0, 0]) {
+//         const keys = ['x', 'y', 'z', 'w'];
+//         const result = {};
+//         array.map((item, index) => {
+//             result[keys[index]] = item;
+//         });
+//         return result;
+//     },
+// };
+// export default MathExtra;
+
+
+exports.radToDeg = radToDeg;

package/dist/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/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/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;