diginext-utils 0.0.1

package/src/FileUtils.js

@@ -0,0 +1,30 @@
+import _ from "lodash";
+
+export default class FileUtils {
+	static getExtensionVideo(file) {
+		var extension = "";
+
+		if (file.type.indexOf("quicktime") >= 0) extension = ".mov";
+		else if (file.type.indexOf("avi") >= 0) extension = ".avi";
+		else if (file.type.indexOf("mpeg") >= 0) extension = ".mpg";
+		else if (file.type.indexOf("wmv") >= 0) extension = ".wmv";
+		else if (file.type.indexOf("ogg") >= 0) extension = ".ogg";
+		else if (file.type.indexOf("webm") >= 0) extension = ".webm";
+		else if (file.type.indexOf("mpeg-4") >= 0) extension = ".mp4";
+		else if (file.type.indexOf("mp4") >= 0) extension = ".mp4";
+
+		return extension;
+	}
+
+	static getFileExtension(file) {
+		const fn = file.name || file.originalFilename;
+		let _f = fn.includes(".") ? fn.split(".") : [""];
+		return _f[_f.length - 1];
+	}
+
+	static getFileNameByUrl(urlStr) {
+		let _u = urlStr.toString();
+		let _a = _u.includes("/") ? _u.split("/") : [];
+		return _.last(_a);
+	}
+}

package/src/MathExtra.js

@@ -0,0 +1,172 @@
+var DEG2RAD = Math.PI / 180;
+var RAD2DEG = 180 / Math.PI;
+
+export default {
+	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;
+	},
+
+	randRound: function (number) {
+		return Math.round(Math.random() * number);
+	},
+
+	rand(number) {
+		return (Math.random() - Math.random()) * number;
+	},
+
+	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);
+	},
+
+	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
+
+	randInt(low, high) {
+		return low + Math.floor(Math.random() * (high - low + 1));
+	},
+
+	// Random float from <low, high> interval
+
+	randFloat(low, high) {
+		return low + Math.random() * (high - low);
+	},
+
+	// 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),
+		};
+	},
+
+	degToRad(degrees) {
+		return degrees * DEG2RAD;
+	},
+
+	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;
+	},
+};

package/src/OS.js

@@ -0,0 +1,203 @@
+export default (options) => {
+	const isIos = () => {
+		if (typeof window.deviceInfo == "undefined") check();
+		var os = window.deviceInfo.os.toLowerCase();
+
+		return os.includes("ios");
+	};
+
+	const isAndroid = () => {
+		if (typeof window.deviceInfo == "undefined") check();
+		var os = window.deviceInfo.os.toLowerCase();
+
+		return os.includes("android");
+	};
+
+	const check = () => {
+		option = option != undefined ? option : {};
+
+		var callback = option.hasOwnProperty("callback") ? option.callback : null;
+
+		if (typeof window.deviceInfo == "undefined") {
+			var unknown = "-";
+
+			// screen
+			var screenSize = "";
+			if (screen.width) {
+				var width = screen.width ? screen.width : "";
+				var height = screen.height ? screen.height : "";
+				screenSize += "" + width + " x " + height;
+			}
+
+			// browser
+			var nVer = navigator.appVersion;
+			var nAgt = navigator.userAgent;
+			var browser = navigator.appName;
+			var version = "" + parseFloat(navigator.appVersion);
+			var majorVersion = parseInt(navigator.appVersion, 10);
+			var nameOffset, verOffset, ix;
+
+			// Opera
+			if ((verOffset = nAgt.indexOf("Opera")) != -1) {
+				browser = "Opera";
+				version = nAgt.substring(verOffset + 6);
+				if ((verOffset = nAgt.indexOf("Version")) != -1) {
+					version = nAgt.substring(verOffset + 8);
+				}
+			}
+			// Opera Next
+			if ((verOffset = nAgt.indexOf("OPR")) != -1) {
+				browser = "Opera";
+				version = nAgt.substring(verOffset + 4);
+			}
+			// Edge
+			else if ((verOffset = nAgt.indexOf("Edge")) != -1) {
+				browser = "Microsoft Edge";
+				version = nAgt.substring(verOffset + 5);
+			}
+			// MSIE
+			else if ((verOffset = nAgt.indexOf("MSIE")) != -1) {
+				browser = "Microsoft Internet Explorer";
+				version = nAgt.substring(verOffset + 5);
+			}
+			// Chrome
+			else if ((verOffset = nAgt.indexOf("Chrome")) != -1) {
+				browser = "Chrome";
+				version = nAgt.substring(verOffset + 7);
+			}
+			// Safari
+			else if ((verOffset = nAgt.indexOf("Safari")) != -1) {
+				browser = "Safari";
+				version = nAgt.substring(verOffset + 7);
+				if ((verOffset = nAgt.indexOf("Version")) != -1) {
+					version = nAgt.substring(verOffset + 8);
+				}
+			}
+			// Firefox
+			else if ((verOffset = nAgt.indexOf("Firefox")) != -1) {
+				browser = "Firefox";
+				version = nAgt.substring(verOffset + 8);
+			}
+			// MSIE 11+
+			else if (nAgt.indexOf("Trident/") != -1) {
+				browser = "Microsoft Internet Explorer";
+				version = nAgt.substring(nAgt.indexOf("rv:") + 3);
+			}
+			// Other browsers
+			else if ((nameOffset = nAgt.lastIndexOf(" ") + 1) < (verOffset = nAgt.lastIndexOf("/"))) {
+				browser = nAgt.substring(nameOffset, verOffset);
+				version = nAgt.substring(verOffset + 1);
+				if (browser.toLowerCase() == browser.toUpperCase()) {
+					browser = navigator.appName;
+				}
+			}
+			// trim the version string
+			if ((ix = version.indexOf(";")) != -1) version = version.substring(0, ix);
+			if ((ix = version.indexOf(" ")) != -1) version = version.substring(0, ix);
+			if ((ix = version.indexOf(")")) != -1) version = version.substring(0, ix);
+
+			majorVersion = parseInt("" + version, 10);
+			if (isNaN(majorVersion)) {
+				version = "" + parseFloat(navigator.appVersion);
+				majorVersion = parseInt(navigator.appVersion, 10);
+			}
+
+			// mobile version
+			var mobile = /Mobile|mini|Fennec|Android|iP(ad|od|hone)/.test(nVer);
+
+			// cookie
+			var cookieEnabled = navigator.cookieEnabled ? true : false;
+
+			if (typeof navigator.cookieEnabled == "undefined" && !cookieEnabled) {
+				document.cookie = "testcookie";
+				cookieEnabled = document.cookie.indexOf("testcookie") != -1 ? true : false;
+			}
+
+			// system
+			var os = unknown;
+			var clientStrings = [
+				{ s: "Windows 10", r: /(Windows 10.0|Windows NT 10.0)/ },
+				{ s: "Windows 8.1", r: /(Windows 8.1|Windows NT 6.3)/ },
+				{ s: "Windows 8", r: /(Windows 8|Windows NT 6.2)/ },
+				{ s: "Windows 7", r: /(Windows 7|Windows NT 6.1)/ },
+				{ s: "Windows Vista", r: /Windows NT 6.0/ },
+				{ s: "Windows Server 2003", r: /Windows NT 5.2/ },
+				{ s: "Windows XP", r: /(Windows NT 5.1|Windows XP)/ },
+				{ s: "Windows 2000", r: /(Windows NT 5.0|Windows 2000)/ },
+				{ s: "Windows ME", r: /(Win 9x 4.90|Windows ME)/ },
+				{ s: "Windows 98", r: /(Windows 98|Win98)/ },
+				{ s: "Windows 95", r: /(Windows 95|Win95|Windows_95)/ },
+				{ s: "Windows NT 4.0", r: /(Windows NT 4.0|WinNT4.0|WinNT|Windows NT)/ },
+				{ s: "Windows CE", r: /Windows CE/ },
+				{ s: "Windows 3.11", r: /Win16/ },
+				{ s: "Android", r: /Android/ },
+				{ s: "Open BSD", r: /OpenBSD/ },
+				{ s: "Sun OS", r: /SunOS/ },
+				{ s: "Linux", r: /(Linux|X11)/ },
+				{ s: "iOS", r: /(iPhone|iPad|iPod)/ },
+				{ s: "Mac OS X", r: /Mac OS X/ },
+				{ s: "Mac OS", r: /(MacPPC|MacIntel|Mac_PowerPC|Macintosh)/ },
+				{ s: "QNX", r: /QNX/ },
+				{ s: "UNIX", r: /UNIX/ },
+				{ s: "BeOS", r: /BeOS/ },
+				{ s: "OS/2", r: /OS\/2/ },
+				{ s: "Search Bot", r: /(nuhk|Googlebot|Yammybot|Openbot|Slurp|MSNBot|Ask Jeeves\/Teoma|ia_archiver)/ },
+			];
+			for (var id in clientStrings) {
+				var cs = clientStrings[id];
+				if (cs.r.test(nAgt)) {
+					os = cs.s;
+					break;
+				}
+			}
+
+			var osVersion = unknown;
+
+			if (/Windows/.test(os)) {
+				osVersion = /Windows (.*)/.exec(os)[1];
+				os = "Windows";
+			}
+
+			switch (os) {
+				case "Mac OS X":
+					osVersion = /Mac OS X (10[\.\_\d]+)/.exec(nAgt)[1];
+					break;
+
+				case "Android":
+					osVersion = /Android ([\.\_\d]+)/.exec(nAgt)[1];
+					break;
+
+				case "iOS":
+					osVersion = /OS (\d+)_(\d+)_?(\d+)?/.exec(nVer);
+					osVersion = osVersion[1] + "." + osVersion[2] + "." + (osVersion[3] | 0);
+					break;
+			}
+
+			// flash (you'll need to include swfobject)
+			/* script src="//ajax.googleapis.com/ajax/libs/swfobject/2.2/swfobject.js" */
+			var flashVersion = "no check";
+			if (typeof swfobject != "undefined") {
+				var fv = swfobject.getFlashPlayerVersion();
+				if (fv.major > 0) {
+					flashVersion = fv.major + "." + fv.minor + " r" + fv.release;
+				} else {
+					flashVersion = unknown;
+				}
+			}
+
+			window.deviceInfo = {
+				screen: screenSize,
+				browser: browser,
+				browserVersion: version,
+				browserMajorVersion: majorVersion,
+				mobile: mobile,
+				os: os,
+				osVersion: osVersion,
+				cookies: cookieEnabled,
+				flashVersion: flashVersion,
+			};
+		}
+
+		if (callback != null) callback(window.deviceInfo);
+	};
+};

package/src/ObjectExtra.js

@@ -0,0 +1,109 @@
+import ArrayExtra from "./ArrayExtra";
+
+export default class ObjectExtra {
+	static getKeyByValue(object, value) {
+		return Object.keys(object).find((key) => object[key] === value);
+	}
+
+	static randomValue(obj) {
+		return obj[this.randomKey(obj)];
+	}
+
+	static randomKey(obj) {
+		var keys = Object.keys(obj);
+		return keys[(keys.length * Math.random()) << 0];
+	}
+
+	static randomElementIndex(obj) {
+		var keys = Object.keys(obj);
+		return (keys.length * Math.random()) << 0;
+	}
+
+	static getObjectLength(obj) {
+		var keys = Object.keys(obj);
+		return keys.length;
+	}
+
+	/**
+	 *
+	 * @param {Object} obj
+	 * @param {Function} cb
+	 */
+	static forEach(obj, cb) {
+		const keys = Object.keys(obj);
+
+		keys.map((key, index) => {
+			if (cb) cb(key, obj[key], index);
+		});
+	}
+
+	/**
+	 *
+	 * @param {Object} object
+	 * @returns {Array} list keys
+	 */
+	static toArray(obj) {
+		let array = [];
+		for (const key in obj) {
+			array.push(obj[key]);
+		}
+		return array;
+	}
+
+	/**
+	 *
+	 * @param {Object} object
+	 * @returns {Object}
+	 */
+	static sortObjectByKey(object) {
+		let array = [];
+
+		for (const key in object) {
+			array.push({
+				key: key,
+				value: object[key],
+			});
+		}
+
+		array = ArrayExtra.sortElementByString(array, "key");
+
+		let result = {};
+
+		array.forEach((item) => {
+			result[item.key] = item.value;
+		});
+
+		return result;
+	}
+
+	//
+
+	static isNull(object) {
+		if (typeof object == "undefined") {
+			return true;
+		}
+		if (Array.isArray(object)) return object.length == 0;
+		return object == null;
+	}
+
+	static toBool(object) {
+		if (this.isNull(object)) return false;
+		object = object.toString();
+
+		return object === "true" || object == "1";
+	}
+
+	static toInt(object) {
+		if (this.isNull(object)) return 0;
+		object = object.toString();
+
+		return parseInt(object, 10);
+	}
+
+	static toFloat(object) {
+		if (this.isNull(object)) return 0;
+		object = object.toString();
+
+		return parseFloat(object);
+	}
+}

package/src/ReactUtils.js

@@ -0,0 +1,25 @@
+import React from "react";
+
+export const isClassComponent = (component) => {
+	return typeof component === "function" && !!component.prototype.isReactComponent;
+};
+
+export const isFunctionComponent = (component) => {
+	return typeof component === "function" && String(component).includes("return React.createElement");
+};
+
+export const isReactComponent = (component) => {
+	return isClassComponent(component) || isFunctionComponent(component);
+};
+
+export const isElement = (element) => {
+	return React.isValidElement(element);
+};
+
+export const isDOMTypeElement = (element) => {
+	return isElement(element) && typeof element.type === "string";
+};
+
+export const isCompositeTypeElement = (element) => {
+	return isElement(element) && typeof element.type === "function";
+};

package/src/ScrollPos.js

@@ -0,0 +1,31 @@
+import React, { useEffect } from "react";
+
+/**
+ *
+ * @param {Element} target DOM element or window | document , default is window
+ * @param {Function} callback handle function
+ * @param {String} eventName Event name
+ */
+const useEventListener = (eventName = "load", callback, options) => {
+	useEffect(() => {
+		options = options || {};
+		let target = options["target"] ? options.target : window || document;
+
+		if (typeof target === "string" && typeof document !== "undefined") {
+			target = document.querySelector(target);
+		}
+
+		if (!target) {
+			// console.log("[useEventListener] target is not defined!");
+			return;
+		}
+		// console.log("[useEventListener]", target);
+		target.addEventListener(eventName, callback);
+
+		return () => {
+			target.removeEventListener(eventName, callback);
+		};
+	}, [eventName, callback]);
+};
+
+export default useEventListener;