@evolis/evolis-library 1.1.0 → 1.2.1

package/EvoArray.js

@@ -0,0 +1,113 @@
+/**
+ * @module EvoArray
+ * @author EmpireDemocratiqueDuPoulpe
+ * @version 1.2.0
+ * @license MIT
+ */
+import EvoObject from "./EvoObject.js";
+import EvoMisc from "./EvoMisc.js";
+
+/*****************************************************
+ * Checkers
+ *****************************************************/
+
+/**
+ * @function isArray
+ *
+ * @param {any} value - The value to test
+ * @returns {boolean} Return true if the value is an array
+ */
+function isArray(value) {
+	return Array.isArray(value);
+}
+
+/**
+ * @function isDeepEqual
+ *
+ * @param {Array} array1 - First array
+ * @param {Array} array2 - Second array
+ * @param {string|null} [sortBy] - Property name used to sort objects in the array. Two identical arrays in different order will not be equal
+ * @returns {Boolean} Are the two array deeply equal ?
+ *
+ * @example
+ * EvoArray.isDeepEqual([{id: 1}, {id: 2}], [{id: 1}, {id: 2}]) // return true
+ * EvoArray.isDeepEqual([{id: 1}, {id: 2}], [{id: 2}, {id: 1}]) // return false
+ * EvoArray.isDeepEqual([{id: 1}, {id: 2}], [{id: 2}, {id: 1}], "id") // return true
+ */
+function isDeepEqual(array1, array2, sortBy = null) {
+	const arr1 = [...array1], arr2 = [...array2];
+	const sort = (a, b) => {
+		if (EvoMisc.isDefined(a) && EvoMisc.isDefined(b)) {
+			return a[sortBy] > b[sortBy] ? 1 : -1;
+		} else {
+			return !EvoMisc.isDefined(a) ? -1 : 1;
+		}
+	};
+
+	if (sortBy) {
+		arr1.sort(sort);
+		arr2.sort(sort);
+	}
+
+	return arr1.every((value, index) => EvoObject.isDeepEqual(arr1[index], arr2[index]));
+}
+
+/*****************************************************
+ * Converters
+ *****************************************************/
+
+/* ---- Array ----------------------------------- */
+/**
+ * @function toSerialComma
+ *
+ * @param {Array<*>} array - The array to convert
+ * @returns {string} A string formatted as a serial comma
+ *
+ * @example
+ * EvoArray.toSerialComma([]) // return ""
+ * EvoArray.toSerialComma(["un", 2, "trois"]) // return "un, 2 et trois"
+ */
+function toSerialComma(array) {
+	return isArray(array) && array.length > 0
+		? array.length === 1
+			? array[0]
+			: `${array.slice(0, -1).join(", ")} et ${array.slice(-1)}`
+		: "";
+}
+
+/*****************************************************
+ * Functions
+ *****************************************************/
+
+/**
+ * @function shuffle
+ *
+ * @param {Array<*>} array - The array to shuffle
+ * @returns {Array<*>} The shuffled array
+ *
+ * @example
+ * EvoArray.shuffle([1, 2, 3]) // return [2, 1, 3] or [3, 2, 1] or [1, 3, 2] or ...
+ */
+function shuffle(array) {
+	let arr = [...array], length = array.length, element, cache;
+
+	while (length) {
+		element = Math.floor(Math.random() * length--);
+
+		cache = arr[length];
+		arr[length] = arr[element];
+		arr[element] = cache;
+	}
+
+	return arr;
+}
+
+/*****************************************************
+ * Export
+ *****************************************************/
+
+export default {
+	isArray, isDeepEqual, // Checkers
+	toSerialComma, // Converters
+	shuffle // Functions
+};

package/EvoDate.js

@@ -0,0 +1,192 @@
+/**
+ * @module EvoDate
+ * @author EmpireDemocratiqueDuPoulpe
+ * @version 1.2.0
+ * @license MIT
+ */
+import EvoString from "./EvoString.js";
+import EvoMisc from "./EvoMisc.js";
+
+/*****************************************************
+ * Checkers
+ *****************************************************/
+
+/**
+ * @function isDate
+ *
+ * @param {any} value - The value to test
+ * @returns {boolean} Return true if the value is a valid date
+ */
+function isDate(value) {
+	return Object.prototype.toString.call(value) === "[object Date]" && !!value.getDate();
+}
+
+/**
+ * @function isMySQLDate
+ *
+ * @param {any} value - The value to test
+ * @returns {boolean} Return true if the value is a string with the valid MySQL date format (yyyy-mm-dd)
+ */
+function isMySQLDate(value) {
+	return EvoString.isString(value) && !EvoString.isBlank(value) && /^\d{4}-\d{1,2}-\d{1,2}$/.test(value);
+}
+
+/*****************************************************
+ * Converters
+ *****************************************************/
+
+/**
+ * @function toDate
+ *
+ * @param {*} d - The thing to convert
+ * @returns {Date|NaN} A date object or NaN if it's not convertible.
+ *
+ * @example
+ * EvoDate.toDate(null) // return NaN
+ * EvoDate.toDate(new Date().toISOString()) // return a Date object
+ */
+function toDate(d) {
+	return (
+		!EvoMisc.isDefined(d) ? NaN :
+			d.constructor === Date ? d :
+				d.constructor === Array ? new Date(d[0],d[1],d[2]) :
+					d.constructor === Number ? new Date(d) :
+						d.constructor === String ? new Date(d) :
+							typeof d === "object" ? new Date(d.year, d.month, (d.date || d.day), d.hours, d.minutes, d.seconds) :
+								NaN
+	);
+}
+
+/**
+ * @function toString
+ *
+ * @param {Date} date - The date to convert
+ * @param {Boolean} [withTime=true] - Include time in the result
+ * @param {string} [locale="fr-FR"] - The locale used in the conversion. It may changed the returned string format
+ * @returns {string} A date formatted like "dd/MM/yyyy [hh:mm:ss]"
+ *
+ * @example
+ * EvoDate.toString(new Date()) // return "13/07/2021, 14:59:48"
+ */
+function toString(date, withTime = true, locale = "fr-FR") {
+	return withTime ? date.toLocaleString(locale) : date.toLocaleDateString(locale);
+}
+
+/**
+ * @function toTimeString
+ *
+ * @param {Date} date - The date to convert
+ * @param {string} [locale="fr-FR"] - The locale used in the conversion. It may changed the returned string format
+ * @returns {string} A date formatted like "hh:mm:ss"
+ *
+ * @example
+ * EvoDate.toTimeString(new Date()) // return "14:59:48"
+ */
+function toTimeString(date, locale = "fr-FR") {
+	return date.toLocaleTimeString(locale);
+}
+
+/**
+ * @function toFieldString
+ *
+ * @param {Date} date - The date to convert
+ * @returns {string} A date formatted like "yyyy-MM-dd"
+ *
+ * @example
+ * EvoDate.toFieldString(new Date()) // return "2021-07-13"
+ */
+function toFieldString(date) {
+	return isDate(date)
+		? `${date.getFullYear()}-${EvoMisc.padLeft(date.getMonth() + 1)}-${EvoMisc.padLeft(date.getDate())}`
+		: null;
+}
+
+/**
+ * @function timeStrToDate
+ *
+ * @param {string} time - The time to convert
+ * @param {string} [format="hh:mm"] - The format used for conversion
+ * @returns {Date} A date object filled with the time string provided
+ * @throws {Error} In case of invalid format/time string
+ *
+ * @example
+ * EvoDate.timeStrToDate("12:57") // works
+ * EvoDate.timeStrToDate("9:21") // works
+ * EvoDate.timeStrToDate("9::21") // error
+ */
+function timeStrToDate(time, format = "hh:mm") {
+	if (!EvoString.isString(time) || !EvoString.isString(format)) return null;
+
+	const now = new Date();
+	const timeSplit = time.split(":");
+	const formatSplit = format.split(":");
+
+	formatSplit.forEach((f, index) => {
+		if (index >= timeSplit.length) throw Error("EvoMisc (timeStrToDate): Supplied format is invalid.");
+		const t = parseInt(timeSplit[index], 10);
+
+		if (f === "hh") now.setHours(t);
+		else if (f === "mm") now.setMinutes(t);
+		else if (f === "ss") now.setSeconds(t);
+	});
+
+	return now;
+}
+
+/**
+ * @function secondsToReadable
+ *
+ * @param {number} seconds - Seconds to convert
+ * @returns {string} The converted seconds and epoch
+ *
+ * @example
+ * EvoDate.secondsToReadable(120) // return "2 minutes"
+ * EvoDate.secondsToReadable(3600) // return "1 heure"
+ */
+function secondsToReadable(seconds) {
+	const epochs = { "années": 31536000, "mois": 2592000, "jours": 86400, "heures": 3600, "minutes": 60, "secondes": 1 };
+	const singular = { "années": "ans", "mois": "mois", "jours": "jour", "heures": "heure", "minutes": "minute", "secondes": "seconde" };
+	const epoch = Object.entries(epochs).filter(([, value]) => seconds >= value).shift();
+	const readable = {
+		epoch: epoch[0],
+		interval: Math.trunc(seconds / epoch[1])
+	};
+
+	if (readable.interval === 1) {
+		readable.epoch = singular[readable.epoch];
+	}
+
+	return `${readable.interval} ${readable.epoch}`;
+}
+
+/*****************************************************
+ * Functions
+ *****************************************************/
+
+/**
+ * @function dayDiff
+ *
+ * @param {Date} start - Start date
+ * @param {Date} end - End date
+ * @returns {Number} How many days between these two dates
+ *
+ * @example
+ * EvoDate.dayDiff(new Date("07/14/2021"), new Date("07/18/2021")) // return 4
+ * EvoDate.dayDiff(new Date("07/14/2021"), new Date("07/01/2021")) // return -13
+ */
+function dayDiff(start, end) {
+	start.setHours(0, 0, 0, 0);
+	end.setHours(0, 0, 0, 0);
+
+	return Math.round((end.getTime() - start.getTime()) / (1000 * 3600 * 24));
+}
+
+/*****************************************************
+ * Export
+ *****************************************************/
+
+export default {
+	isDate, isMySQLDate, // Checkers
+	toDate, toString, toTimeString, toFieldString, timeStrToDate, secondsToReadable, // Converters
+	dayDiff // Functions
+};

package/EvoMisc.js

@@ -0,0 +1,148 @@
+/**
+ * @module EvoMisc
+ * @author EmpireDemocratiqueDuPoulpe
+ * @version 1.2.0
+ * @license MIT
+ */
+import EvoArray from "./EvoArray.js";
+
+/*****************************************************
+ * Checkers
+ *****************************************************/
+
+/**
+ * @function isDefined
+ *
+ * @param {*} value - The value to test
+ * @returns {Boolean} Return true if the value is not undefined or null
+ *
+ * @example
+ * EvoMisc.isDefined("") // return true
+ * EvoMisc.isDefined(65) // return true
+ * EvoMisc.isDefined(false) // return true
+ * EvoMisc.isDefined(null) // return false
+ * EvoMisc.isDefined(undefined) // return false
+ */
+function isDefined(value) {
+	return value !== undefined && value !== null;
+}
+
+/**
+ * @function isEmail
+ *
+ * @param {any} value - The value to test
+ * @returns {boolean} Return true if the value is a string containing a valid email address
+ */
+function isEmail(value) {
+	return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value);
+}
+
+/**
+ * @typedef {Object} PasswordRules
+ *
+ * @property {object} mustContain - What type of character the password must contain
+ * @property {boolean} [mustContain.lowerCase] - Must contain at least one lower cased character
+ * @property {boolean} [mustContain.upperCase] - Must contain at least one upper cased character
+ * @property {boolean} [mustContain.digit] - Must contain at least one number
+ * @property {boolean} [mustContain.special] - Must contain at least one special character
+ * @property {number} minLength - The minimal length
+ */
+
+/**
+ * @const
+ * @type {PasswordRules}
+ */
+export const passwordRules = {
+	mustContain: {
+		lowerCase: true,
+		upperCase: true,
+		digit: true,
+		special: true
+	},
+	minLength: 8
+};
+
+/**
+ * @function isPasswordSafe
+ *
+ * @param {string|Array} password - One or multiple passwords
+ * @param {PasswordRules} [rules] - An object that describe security rules to follow
+ * @returns {boolean} Return true if the value is a safe password
+ */
+function isPasswordSafe(password, rules) {
+	const usedRules = rules ? { ...passwordRules, ...rules } : passwordRules;
+
+	if (EvoArray.isArray(password)) {
+		return password.every(pwd => isPasswordSafe(pwd, usedRules));
+	}
+
+	let regex = "";
+
+	if (usedRules.mustContain.lowerCase) regex += "(?=.*[a-z])";
+	if (usedRules.mustContain.upperCase) regex += "(?=.*[A-Z])";
+	if (usedRules.mustContain.digit) regex += "(?=.*[0-9])";
+	// Replacing backtick (`) with quote (") will break the check for some dark magic reason
+	// eslint-disable-next-line quotes
+	if (usedRules.mustContain.special) regex += `(?=.*[\\"'!?@#$£%^&:;<>\\[\\]()\\\\\\-_+=*.])`;
+	regex += `.{${usedRules.minLength},}$`;
+
+	const strongPwd = new RegExp(regex);
+	return strongPwd.test(password);
+}
+
+/*****************************************************
+ * Converters
+ *****************************************************/
+
+/**
+ * @function bytesToReadable
+ *
+ * @param {number} bytes - Bytes to convert
+ * @param {number} [decimals=2] - How many decimals
+ * @returns {string} The converted bytes size to the closest unit
+ *
+ * @example
+ * EvoMisc.bytesToReadable(8000000) // return "7.63 MB"
+ * EvoMisc.bytesToReadable(8000000, 0) // return "8 MB"
+ */
+function bytesToReadable(bytes, decimals = 2) {
+	if (bytes === 0) return "0 Bytes";
+
+	const k = 1024;
+	const dm = decimals < 0 ? 0 : decimals;
+	const sizes = ["Bytes", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"];
+
+	const i = Math.floor(Math.log(bytes) / Math.log(k));
+	return `${parseFloat((bytes / Math.pow(k, i)).toFixed(dm))} ${sizes[i]}`;
+}
+
+/*****************************************************
+ * Functions
+ *****************************************************/
+
+/**
+ * @function padLeft
+ *
+ * @param {*} value - The value to pad
+ * @param {string} [pad="00"] - With what to pad
+ * @returns {string} The padded string
+ *
+ * @example
+ * EvoMisc.padLeft(5, "000") // return "005"
+ * EvoMisc.padLeft("796", "00") // return "796"
+ */
+function padLeft(value, pad = "00") {
+	return isDefined(value)
+		? (value.toString().length >= pad.length) ? value : (pad + value).slice(-pad.length)
+		: pad;
+}
+
+/*****************************************************
+ * Export
+ *****************************************************/
+
+export default {
+	isDefined, isEmail, isPasswordSafe, // Checkers
+	bytesToReadable, // Converters
+	padLeft // Functions
+};

package/EvoNumber.js

@@ -0,0 +1,44 @@
+/**
+ * @module EvoNumber
+ * @author EmpireDemocratiqueDuPoulpe
+ * @version 1.2.0
+ * @license MIT
+ */
+import EvoString from "./EvoString.js";
+
+/*****************************************************
+ * Checkers
+ *****************************************************/
+/**
+ * @function isNumber
+ *
+ * @param {any} value - The value to test
+ * @param {boolean} [parse=false] - If set to true, the function will parse the value to find a integer (base 10)
+ * @returns {boolean} Return true if the value is a number
+ */
+function isNumber(value, parse = false) {
+	const val = parse ? (EvoString.isString(value) ? parseInt(value, 10) : value) : value;
+	return typeof val === "number" && !isNaN(val);
+}
+
+/**
+ * @function isFloat
+ *
+ * @param {any} value - The value to test
+ * @param {boolean} [parse=false] - If set to true, the function will parse the value to find a float
+ * @returns {boolean} Return true if the value is a float
+ */
+function isFloat(value, parse = true) {
+	const val = parse ? (EvoString.isString(value) ? parseFloat(value) : value) : value;
+	return typeof val === "number" && !isNaN(val);
+}
+
+/*****************************************************
+ * Export
+ *****************************************************/
+
+export default {
+	isNumber, isFloat // Checkers
+	// Converters
+	// Functions
+};

package/EvoObject.js

@@ -0,0 +1,40 @@
+/**
+ * @module EvoObject
+ * @author EmpireDemocratiqueDuPoulpe
+ * @version 1.2.0
+ * @license MIT
+ */
+
+/*****************************************************
+ * Checkers
+ *****************************************************/
+
+/**
+ * @function isDeepEqual
+ *
+ * @param {Object} obj1 - First object
+ * @param {Object} obj2 - Second object
+ * @returns {Boolean} Are the two objects deeply equal ?
+ *
+ * @example
+ * EvoObject.isDeepEqual({id: 1, title: "skibidi wap-pa-pa"}, {title: "skibidi wap-pa-pa", id: 1}) // return true
+ * EvoObject.isDeepEqual({id: 7, title: "skibidi wap-pa-pa"}, {title: "skibidi woosh-oosh-oosh", id: 1}) // return false
+ */
+function isDeepEqual(obj1, obj2) {
+	if (typeof obj1 === "object" && Object.keys(obj1).length > 0) {
+		return Object.keys(obj1).length === Object.keys(obj2).length &&
+			Object.keys(obj1).every(prop => isDeepEqual(obj1[prop], obj2[prop]));
+	} else {
+		return obj1 === obj2;
+	}
+}
+
+/*****************************************************
+ * Export
+ *****************************************************/
+
+export default {
+	isDeepEqual // Checkers
+	// Converters
+	// Functions
+};

package/EvoString.js

@@ -0,0 +1,88 @@
+/**
+ * @module EvoString
+ * @author EmpireDemocratiqueDuPoulpe
+ * @version 1.2.0
+ * @license MIT
+ */
+import EvoArray from "./EvoArray.js";
+import EvoMisc from "./EvoMisc.js";
+
+/*****************************************************
+ * Checkers
+ *****************************************************/
+
+/**
+ * @function isString
+ *
+ * @param {any} value - The value to test
+ * @returns {boolean} Return true if the value is a string
+ */
+function isString(value) {
+	return Object.prototype.toString.call(value) === "[object String]";
+}
+
+/**
+ * @function isEmpty
+ *
+ * @param {any} value - The value to test
+ * @returns {boolean} Return true if the value is a string and if its empty
+ *
+ * @example
+ * EvoString.isEmpty(""); // return true
+ * EvoString.isEmpty(" "); // return false
+ */
+function isEmpty(value) {
+	return value === "";
+}
+
+/**
+ * @function isBlank
+ *
+ * @param {any} value - The value to test
+ * @returns {boolean} Return true if the value is a string and if its blank
+ *
+ * @example
+ * EvoString.isBlank(""); // return true
+ * EvoString.isBlank(" "); // return true
+ */
+function isBlank(value) {
+	return isString(value) && value.trim().length === 0;
+}
+
+/**
+ * @function inRange
+ *
+ * @param {*|Array<*>} value - The value to test
+ * @param {Number} min - The minimum length of the string (nullable)
+ * @param {Number} max - The maximum length of the string (nullable)
+ * @param {Boolean} [includeBounds=true] - Include the min and max bounds in the range
+ * @param {Boolean} [canBeNull=false] - Authorize or not the string to be null or undefined
+ * @returns {Boolean} Return true if the value is a string between min and max or if it's an undefined/null with canBeNull set at true.
+ *
+ * @example
+ * EvoString.inRange("never gonna give you up", null, 100); // return true
+ * EvoString.inRange("oof", 5); // return false
+ */
+function inRange(value, min, max, includeBounds = true, canBeNull = false) {
+	if (EvoArray.isArray(value)) {
+		return value.every(s => inRange(s, min, max, includeBounds, canBeNull));
+	}
+
+	return EvoMisc.isDefined(value)
+		? isString(value)
+			? includeBounds
+				? (EvoMisc.isDefined(min) ? value.length >= min : true) && (EvoMisc.isDefined(max) ? value.length <= max : true)
+				: (EvoMisc.isDefined(min) ? value.length > min : true) && (EvoMisc.isDefined(max) ? value.length < max : true)
+			: false
+		: canBeNull;
+}
+
+/*****************************************************
+ * Export
+ *****************************************************/
+
+export default {
+	isString, isEmpty, isBlank, inRange // Checkers
+	// Converters
+	// Functions
+};