diginext-utils 0.0.1

package/src/Uuid.js

@@ -0,0 +1,66 @@
+export default function generateUUID() {
+	// http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript/21963136#21963136
+	var lut = [];
+	for (var i = 0; i < 256; i++) {
+		lut[i] = (i < 16 ? "0" : "") + i.toString(16);
+	}
+
+	function _generateUUID() {
+		var d0 = (Math.random() * 0xffffffff) | 0;
+		var d1 = (Math.random() * 0xffffffff) | 0;
+		var d2 = (Math.random() * 0xffffffff) | 0;
+		var d3 = (Math.random() * 0xffffffff) | 0;
+		var uuid =
+			lut[d0 & 0xff] +
+			lut[(d0 >> 8) & 0xff] +
+			lut[(d0 >> 16) & 0xff] +
+			lut[(d0 >> 24) & 0xff] +
+			"-" +
+			lut[d1 & 0xff] +
+			lut[(d1 >> 8) & 0xff] +
+			"-" +
+			lut[((d1 >> 16) & 0x0f) | 0x40] +
+			lut[(d1 >> 24) & 0xff] +
+			"-" +
+			lut[(d2 & 0x3f) | 0x80] +
+			lut[(d2 >> 8) & 0xff] +
+			"-" +
+			lut[(d2 >> 16) & 0xff] +
+			lut[(d2 >> 24) & 0xff] +
+			lut[d3 & 0xff] +
+			lut[(d3 >> 8) & 0xff] +
+			lut[(d3 >> 16) & 0xff] +
+			lut[(d3 >> 24) & 0xff];
+
+		// .toUpperCase() here flattens concatenated strings to save heap memory space.
+		return uuid.toUpperCase();
+	}
+
+	return _generateUUID();
+}
+
+// export default {
+//   get generateUUID() {
+//     // http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript/21963136#21963136
+//     var lut = [];
+//     for (var i = 0; i < 256; i++) {
+//       lut[i] = (i < 16 ? '0' : '') + (i).toString(16);
+//     }
+
+//     function _generateUUID() {
+//       var d0 = Math.random() * 0xffffffff | 0;
+//       var d1 = Math.random() * 0xffffffff | 0;
+//       var d2 = Math.random() * 0xffffffff | 0;
+//       var d3 = Math.random() * 0xffffffff | 0;
+//       var uuid = lut[d0 & 0xff] + lut[d0 >> 8 & 0xff] + lut[d0 >> 16 & 0xff] + lut[d0 >> 24 & 0xff] + '-' +
+//         lut[d1 & 0xff] + lut[d1 >> 8 & 0xff] + '-' + lut[d1 >> 16 & 0x0f | 0x40] + lut[d1 >> 24 & 0xff] + '-' +
+//         lut[d2 & 0x3f | 0x80] + lut[d2 >> 8 & 0xff] + '-' + lut[d2 >> 16 & 0xff] + lut[d2 >> 24 & 0xff] +
+//         lut[d3 & 0xff] + lut[d3 >> 8 & 0xff] + lut[d3 >> 16 & 0xff] + lut[d3 >> 24 & 0xff];
+
+//       // .toUpperCase() here flattens concatenated strings to save heap memory space.
+//       return uuid.toUpperCase();
+//     };
+
+//     return _generateUUID()
+//   },
+// }

package/src/Validation.js

@@ -0,0 +1,35 @@
+export default {
+	imageValidate(file) {
+		// console.log("imageValidate")
+		var maxSize = 10;
+		var fileSize = 1024 * 1024 * maxSize; // 10mb
+		var fileTypes = ["image/png", "image/jpeg"];
+		// var isFileValid = true;
+		if (!file || fileTypes.indexOf(file.type) < 0) {
+			alert("Vui lòng upload ảnh đúng định dạng jpg hay png");
+			return false;
+		} else if (file.size > fileSize) {
+			alert("Vui lòng upload ảnh có dung lượng thấp hơn " + maxSize + "mb");
+			return false;
+		}
+		return true;
+	},
+
+	videoValidate(file) {
+		// console.log("videoValidate")
+
+		var maxSize = 15;
+		var fileSize = 1024 * 1024 * maxSize; // 10mb
+		var fileTypes = "video";
+		// console.log(file.type)
+		// var isFileValid = true;
+		if (!file || file.type.indexOf(fileTypes) < 0) {
+			alert("Vui lòng upload video");
+			return false;
+		} else if (file.size > fileSize) {
+			alert("Vui lòng upload video có dung lượng thấp hơn " + maxSize + "mb");
+			return false;
+		}
+		return true;
+	},
+};

package/src/array/index.js

@@ -0,0 +1,301 @@
+import { randInt } from "../math";
+
+/**
+ *
+ * @param {Array} array
+ * @param {string} key
+ * @returns {Number}
+*/
+export 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}
+ */
+export const averageArray = (array, key) => {
+    if (!array) {
+        console.warn("ARRAY NOT EXITED !");
+        return 0;
+    }
+    return this.sum(array, key) / array.length || 0;
+};
+
+/**
+ *
+ * @param {Array} array
+ * @param {string} key
+ * @returns {Number}
+ */
+export 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}
+ */
+export 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}
+ */
+export 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}
+ */
+export 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}
+ */
+export const firstElement = (array) => {
+    if (array) if (array.length || array.length > 0) return array[0];
+    return null;
+};
+
+/**
+ *
+ * @param {Array} array
+ * @returns {any}
+ */
+export const lastElement = (array) => {
+    if (array) if (array.length || array.length > 0) return array[array.length - 1];
+    return null;
+};
+
+/**
+ *
+ * @param {Array} array
+ * @returns {any}
+ */
+export const randomIndex = (array) => {
+    if (array) return randInt(0, array.length - 1);
+    return -1;
+};
+
+/**
+ *
+ * @param {Array} array
+ * @returns {any}
+ */
+export 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}
+ */
+export 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}
+ */
+export 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}
+ */
+export 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}
+ */
+export 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}
+ */
+ export 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}
+ */
+ export const getHalfRandom = (array, n) => {
+	var n = Math.ceil(array.length / 2);
+	return array.getRandom(n);
+};
+
+/**
+ * Make array shuffle itself
+ * @param {Array} array
+ * @returns {Array}
+ */
+ export 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}
+ */
+ export 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; 
+};
+
+
+export 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;
+};

package/src/backend/file/createDir.js

@@ -0,0 +1,13 @@
+const fs = require("fs");
+
+/**
+ *
+ * @param {string} path
+ */
+export default function createDir(path) {
+	if (fs.existsSync(path)) {
+		console.log("directory already exited !");
+		return true;
+	}
+	fs.mkdirSync(path, { recursive: true });
+}

package/src/backend/file/fileMove.js

@@ -0,0 +1,35 @@
+const fs = require("fs");
+
+/**
+ *
+ * @param {string} oldPath
+ * @param {string} newPath
+ * @param {Function} callback
+ */
+export default 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/src/backend/file/findFilesByExt.js

@@ -0,0 +1,42 @@
+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 (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);
+};
+
+export default forEachFileByExt;

package/src/backend/zip/extractZip.js

@@ -0,0 +1,58 @@
+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;

package/src/device/browser.js

@@ -0,0 +1,29 @@
+export 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);
+};
+
+export const isLandscape = (params) => {
+	return !isPotrait();
+};
+
+export const ua = (params) => {
+	if (typeof navigator == "undefined") return null;
+	if (typeof window == "undefined") return null;
+
+	return navigator.userAgent || navigator.vendor || window.opera;
+};
+
+export const isFacebookWebview = (params) => {
+	var ua = ua();
+	if (ua) return ua.indexOf("FBAN") > -1 || ua.indexOf("FBAV") > -1;
+};
+
+export const isInAppWebview = (params) => {
+	const rules = ["WebView", "(iPhone|iPod|iPad)(?!.*Safari/)", "Android.*(wv|.0.0.0)"];
+	const regex = new RegExp(`(${rules.join("|")})`, "ig");
+	if (ua()) return Boolean(ua().match(regex));
+	return false;
+};