diginext-utils 1.0.2 → 1.0.3

package/dist/array/index.js

@@ -0,0 +1,377 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.sumArray = exports.sortElementByString = exports.sortElementByNumber = exports.shuffle = exports.removeItemByKey = exports.removeItem = exports.randomIndex = exports.randomElement = exports.moveIndex = exports.moveArray = exports.minArray = exports.mergeAndMakeUniqueElement = exports.maxArray = exports.lastElement = exports.getRandom = exports.getHalfRandom = exports.firstElement = exports.averageArray = exports.allMatchInArray = void 0;
+
+require("core-js/modules/es.array.reduce.js");
+
+require("core-js/modules/es.array.sort.js");
+
+require("core-js/modules/es.array.includes.js");
+
+require("core-js/modules/es.string.includes.js");
+
+var _math = require("../math");
+
+/**
+ *
+ * @param {Array} array
+ * @param {string} key
+ * @returns {Number}
+*/
+const sumArray = (array, key) => {
+  if (!array) {
+    console.warn("ARRAY NOT EXITED !");
+    return 0;
+  }
+
+  if (key) return array.reduce((c, v) => c + v[key], 0);else return array.reduce((c, v) => c + v, 0);
+};
+/**
+ *
+ * @param {Array} array
+ * @param {string} key
+ * @returns {Number}
+ */
+
+
+exports.sumArray = sumArray;
+
+const averageArray = (array, key) => {
+  if (!array) {
+    console.warn("ARRAY NOT EXITED !");
+    return 0;
+  }
+
+  return (void 0).sum(array, key) / array.length || 0;
+};
+/**
+ *
+ * @param {Array} array
+ * @param {string} key
+ * @returns {Number}
+ */
+
+
+exports.averageArray = averageArray;
+
+const minArray = (array, key) => {
+  if (!array) {
+    console.warn("ARRAY NOT EXITED !");
+    return 0;
+  }
+
+  if (array.length > 0) {
+    if (key) return array.reduce((c, v) => c < v[key] ? c : v[key]);else return array.reduce((c, v) => c < v ? c : v);
+  }
+
+  return 0;
+};
+/**
+ *
+ * @param {Array} array
+ * @param {string} key
+ * @returns {Number}
+ */
+
+
+exports.minArray = minArray;
+
+const maxArray = (array, key) => {
+  if (!array) {
+    console.warn("ARRAY NOT EXITED !");
+    return 0;
+  }
+
+  if (array.length > 0) {
+    if (key) return array.reduce((c, v) => c > v[key] ? c : v[key]);else return array.reduce((c, v) => c > v ? c : v);
+  }
+
+  return 0;
+};
+/**
+ *
+ * @param {Array} array
+ * @param {string} key
+ * @returns {Array}
+ */
+
+
+exports.maxArray = maxArray;
+
+const sortElementByString = (array, key) => {
+  if (!Array.isArray(array)) return [];
+  if (key) return array.sort((x, y) => {
+    var a = x[key].toUpperCase(),
+        b = y[key].toUpperCase();
+    return a == b ? 0 : a > b ? 1 : -1;
+  });
+  console.log("NO KEY");
+};
+/**
+ *
+ * @param {Array} array
+ * @param {string} key
+ * @returns {Array}
+ */
+
+
+exports.sortElementByString = sortElementByString;
+
+const sortElementByNumber = (array, key) => {
+  if (!Array.isArray(array)) return [];
+  if (key) return array.sort((a, b) => {
+    return a[key] - b[key];
+  });
+  console.log("NO KEY");
+};
+/**
+ *
+ * @param {Array} array
+ * @returns {any}
+ */
+
+
+exports.sortElementByNumber = sortElementByNumber;
+
+const firstElement = array => {
+  if (array) if (array.length || array.length > 0) return array[0];
+  return null;
+};
+/**
+ *
+ * @param {Array} array
+ * @returns {any}
+ */
+
+
+exports.firstElement = firstElement;
+
+const lastElement = array => {
+  if (array) if (array.length || array.length > 0) return array[array.length - 1];
+  return null;
+};
+/**
+ *
+ * @param {Array} array
+ * @returns {any}
+ */
+
+
+exports.lastElement = lastElement;
+
+const randomIndex = array => {
+  if (array) return (0, _math.randInt)(0, array.length - 1);
+  return -1;
+};
+/**
+ *
+ * @param {Array} array
+ * @returns {any}
+ */
+
+
+exports.randomIndex = randomIndex;
+
+const randomElement = array => {
+  if (array) return array[randomIndex(array)];
+  return null;
+};
+/**
+ * Remove same elements from 2 arrays
+ * @param {Array} list1
+ * @param {Array} list2
+ * @param {string} key
+ * @returns {Array}
+ */
+
+
+exports.randomElement = randomElement;
+
+const mergeAndMakeUniqueElement = (list1, list2, key) => {
+  if (!list1 || !list2) return;
+
+  if (key) {
+    return list1.concat(list2).filter((item, index, self) => {
+      return self.findIndex(x => x[key] == item[key]) === index;
+    });
+  } else {
+    return list1.concat(list2).filter((x, index, self) => {
+      return self.indexOf(x) === index;
+    });
+  }
+};
+/**
+ * check target == toMatch
+ * @param {Array} target
+ * @param {Array} toMatch
+ * @returns {Boolean}
+ */
+
+
+exports.mergeAndMakeUniqueElement = mergeAndMakeUniqueElement;
+
+const allMatchInArray = (target, toMatch) => {
+  if (!target || !toMatch) return false;
+  const found = toMatch.every(item => {
+    return target.includes(item);
+  });
+  return found;
+};
+/**
+ *
+ * @param {any} item
+ * @param {Array} array
+ * @returns {Array}
+ */
+
+
+exports.allMatchInArray = allMatchInArray;
+
+const removeItem = (item, array) => {
+  const index = array.indexOf(item);
+
+  if (index == -1) {
+    console.warn("[ArrayExtra.removeItem] Item not found.");
+    return array;
+  }
+
+  array.splice(index, 1);
+  return array;
+};
+/**
+ *
+ * @param {string} key
+ * @param {any} value
+ * @param {Array} array
+ * @returns {Array}
+ */
+
+
+exports.removeItem = removeItem;
+
+const removeItemByKey = (key, value, array) => {
+  const foundIndex = array.findIndex(item => {
+    return item[key] == value;
+  });
+
+  if (foundIndex < 0) {
+    console.warn("[ArrayExtra.removeItemByKey] Item not found.", key, value);
+    return array;
+  }
+
+  array.splice(foundIndex, 1);
+  return array;
+};
+/**
+ * Get an array with shuffle element
+ * @param {Array} array
+ * @param {Number} n
+ * @returns {Array}
+ */
+
+
+exports.removeItemByKey = removeItemByKey;
+
+const getRandom = (array, n) => {
+  var result = new Array(n),
+      len = array.length,
+      taken = new Array(len);
+  if (n > len) throw new RangeError("getRandom: more elements taken than available");
+
+  while (n--) {
+    var x = Math.floor(Math.random() * len);
+    result[n] = array[x in taken ? taken[x] : x];
+    taken[x] = --len in taken ? taken[len] : len;
+  }
+
+  return result;
+};
+/**
+ * Get an array with shuffle element
+ * @param {Array} array
+ * @param {Number} n
+ * @returns {Array}
+ */
+
+
+exports.getRandom = getRandom;
+
+const getHalfRandom = (array, n) => {
+  var n = Math.ceil(array.length / 2);
+  return array.getRandom(n);
+};
+/**
+ * Make array shuffle itself
+ * @param {Array} array
+ * @returns {Array}
+ */
+
+
+exports.getHalfRandom = getHalfRandom;
+
+const shuffle = array => {
+  var i = array.length,
+      j,
+      temp;
+  if (i == 0) return array;
+
+  while (--i) {
+    j = Math.floor(Math.random() * (i + 1));
+    temp = array[i];
+    array[i] = array[j];
+    array[j] = temp;
+  }
+
+  return array;
+};
+/**
+ *
+ * @param {Array} array
+ * @param {Number} oldIndex
+ * @param {Number} newIndex
+ * @returns {Array}
+ */
+
+
+exports.shuffle = shuffle;
+
+const moveIndex = (array, oldIndex, newIndex) => {
+  if (newIndex >= array.length) {
+    var k = newIndex - array.length + 1;
+
+    while (k--) {
+      array.push(undefined);
+    }
+  }
+
+  array.splice(newIndex, 0, array.splice(oldIndex, 1)[0]);
+  return array;
+};
+
+exports.moveIndex = moveIndex;
+
+const moveArray = (array, oldIndex, newIndex) => {
+  while (oldIndex < 0) {
+    oldIndex += array.length;
+  }
+
+  while (newIndex < 0) {
+    newIndex += array.length;
+  }
+
+  if (newIndex >= array.length) {
+    var k = newIndex - array.length;
+
+    while (k-- + 1) {
+      array.push(999);
+    }
+  }
+
+  array.splice(newIndex, 0, array.splice(oldIndex, 1)[0]);
+  return array;
+};
+
+exports.moveArray = moveArray;

package/dist/backend/file/createDir.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = createDir;
+
+const fs = require("fs");
+/**
+ *
+ * @param {string} path
+ */
+
+
+function createDir(path) {
+  if (fs.existsSync(path)) {
+    console.log("directory already exited !");
+    return true;
+  }
+
+  fs.mkdirSync(path, {
+    recursive: true
+  });
+}

package/dist/backend/file/fileMove.js

@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = fileMove;
+
+const fs = require("fs");
+/**
+ *
+ * @param {string} oldPath
+ * @param {string} newPath
+ * @param {Function} callback
+ */
+
+
+function fileMove(oldPath, newPath, callback) {
+  fs.rename(oldPath, newPath, function (err) {
+    if (err) {
+      if (err.code === "EXDEV") {
+        copy();
+      } else {
+        callback(err);
+      }
+
+      return;
+    }
+
+    callback();
+  });
+
+  function copy() {
+    var readStream = fs.createReadStream(oldPath);
+    var writeStream = fs.createWriteStream(newPath);
+    readStream.on("error", callback);
+    writeStream.on("error", callback);
+    readStream.on("close", function () {
+      fs.unlink(oldPath, callback);
+    });
+    readStream.pipe(writeStream);
+  }
+}

package/dist/backend/file/findFilesByExt.js

@@ -0,0 +1,55 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var path = require("path");
+
+var fs = require("fs");
+/**
+ *
+ * @param {string} base
+ * @param {string} ext
+ * @param {Function} cb
+ */
+
+
+const forEachFileByExt = (base, ext, cb) => {
+  var walk = function walk(directoryName) {
+    try {
+      fs.readdir(directoryName, function (e, files) {
+        if (e) {
+          console.log("Error: ", e);
+          return;
+        }
+
+        files.forEach(function (file) {
+          var fullPath = path.join(directoryName, file);
+          fs.stat(fullPath, function (e, f) {
+            if (e) {
+              console.log("Error: ", e);
+              return;
+            }
+
+            if (f.isDirectory()) {
+              walk(fullPath);
+            } else {
+              if (fullPath.toLowerCase().indexOf(ext.toLowerCase()) > -1) {
+                if (cb) cb(fullPath);
+              }
+            }
+          });
+        });
+      });
+    } catch (error) {
+      console.log("error", error);
+    }
+  };
+
+  walk(base);
+};
+
+var _default = forEachFileByExt;
+exports.default = _default;

package/dist/backend/zip/extractZip.js

@@ -0,0 +1,55 @@
+// import JSZip from "jszip";
+// import ObjectExtra from "plugins/utils/ObjectExtra";
+// import createDir from "../file/createDir";
+// const fs = require("fs");
+// const path = require("path");
+// /**
+//  *
+//  * @param {string} zipPath
+//  * @param {string} directory
+//  * @param {Function} forEach
+//  */
+// const extractZip = async (zipPath, directory, forEach) => {
+// 	// let id = -1;
+// 	// let isCallcb = false;
+// 	fs.readFile(zipPath, async function (err, data) {
+// 		if (err) throw err;
+// 		JSZip.loadAsync(data)
+// 			.then(async function (zip) {
+// 				const _length = ObjectExtra.toArray(zip).length;
+// 				zip.forEach((filePath, fileObj) => {
+// 					console.log(filePath);
+// 					var fileName = path.resolve(directory, filePath);
+// 					if (fileName.indexOf(".DS_Store") >= 0) {
+// 						return;
+// 					}
+// 					if (fileName.indexOf("__MACOSX/") >= 0) {
+// 						return;
+// 					}
+// 					// console.log(fileName)
+// 					if (fileObj.dir) {
+// 						createDir(fileName);
+// 						if (forEach) forEach(fileName, false);
+// 					} else {
+// 						try {
+// 							fileObj.async("nodebuffer").then((buff) => {
+// 								fs.writeFileSync(fileName, buff);
+// 								if (forEach) forEach(fileName, true);
+// 								// id++;
+// 								// if (id >= _length) if (callback && !isCallcb) {
+// 								//     console.log("4")
+// 								//     isCallcb = true;
+// 								//     if (callback) callback();
+// 								// }
+// 							});
+// 						} catch (error) {
+// 							cosole.log("extractZip ERROR", error);
+// 						}
+// 					}
+// 				});
+// 			})
+// 			.then(function () {});
+// 	});
+// };
+// export default extractZip;
+"use strict";

package/dist/console/enableConsole.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = enableConsole;
+
+var _cloneDeep = _interopRequireDefault(require("lodash/cloneDeep"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const _console = (0, _cloneDeep.default)(console);
+
+function enableConsole(params) {
+  return _console;
+}

package/dist/console/index.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.showCredit = exports.disableConsole = void 0;
+
+const disableConsole = params => {
+  for (var i in console) {
+    console[i] = function () {};
+  }
+};
+
+exports.disableConsole = disableConsole;
+
+const showCredit = params => {
+  console.log("Developed by Digitop | https://www.wearetopgroup.com/?utm_src=console");
+};
+
+exports.showCredit = showCredit;

package/dist/device/browser.js

@@ -0,0 +1,52 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ua = exports.isPotrait = exports.isLandscape = exports.isInAppWebview = exports.isFacebookWebview = void 0;
+
+require("core-js/modules/es.regexp.constructor.js");
+
+require("core-js/modules/es.regexp.exec.js");
+
+require("core-js/modules/es.regexp.to-string.js");
+
+require("core-js/modules/es.string.match.js");
+
+const isPotrait = params => {
+  if (typeof window == "undefined") return false;
+  if (!window.orientation) return window.matchMedia("(orientation: portrait)").matches;
+  return !(window.orientation === 90 || window.orientation === -90);
+};
+
+exports.isPotrait = isPotrait;
+
+const isLandscape = params => {
+  return !isPotrait();
+};
+
+exports.isLandscape = isLandscape;
+
+const ua = params => {
+  if (typeof navigator == "undefined") return null;
+  if (typeof window == "undefined") return null;
+  return navigator.userAgent || navigator.vendor || window.opera;
+};
+
+exports.ua = ua;
+
+const isFacebookWebview = params => {
+  var ua = ua();
+  if (ua) return ua.indexOf("FBAN") > -1 || ua.indexOf("FBAV") > -1;
+};
+
+exports.isFacebookWebview = isFacebookWebview;
+
+const isInAppWebview = params => {
+  const rules = ["WebView", "(iPhone|iPod|iPad)(?!.*Safari/)", "Android.*(wv|.0.0.0)"];
+  const regex = new RegExp("(".concat(rules.join("|"), ")"), "ig");
+  if (ua()) return Boolean(ua().match(regex));
+  return false;
+};
+
+exports.isInAppWebview = isInAppWebview;