diginext-utils 2.0.6 → 2.0.8

package/src/array.ts

@@ -0,0 +1,261 @@
+import { randInt } from "./math";
+
+export const sumArray = (array: [], key: string) => {
+	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: string) => {
+	if (!array) {
+		console.warn("ARRAY NOT EXITED !");
+		return 0;
+	}
+	return sumArray(array, key) / array.length || 0;
+};
+
+/**
+ *
+ * @param {Array} array
+ * @param {string} key
+ * @returns {Number}
+ */
+export const minArray = (array: [], key: string) => {
+	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: string) => {
+	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: any, key: string) => {
+	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: any, key: string) => {
+	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: any[]) => {
+	if (array) if (array.length || array.length > 0) return array[0];
+	return null;
+};
+
+/**
+ *
+ * @param {Array} array
+ * @returns {any}
+ */
+export const lastElement = (array: any[]) => {
+	if (array) if (array.length || array.length > 0) return array[array.length - 1];
+	return null;
+};
+
+/**
+ *
+ * @param {Array} array
+ * @returns {any}
+ */
+export const randomIndex = (array: any[]) => {
+	if (array) return randInt(0, array.length - 1);
+	return -1;
+};
+
+/**
+ *
+ * @param {Array} array
+ * @returns {any}
+ */
+export const randomElement = (array: any[]) => {
+	if (array) return array[randomIndex(array)];
+	return null;
+};
+
+/**
+ * Remove same elements from 2 arrays
+ */
+export const mergeAndMakeUniqueElement = (list1: any[], list2: any[], key: string) => {
+	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: any[], toMatch: any[]) => {
+	if (!target || !toMatch) return false;
+	const found = toMatch.every((item) => {
+		return target.includes(item);
+	});
+	return found;
+};
+
+export const removeItem = (item: any, array: any[]) => {
+	const index = array.indexOf(item);
+	if (index == -1) {
+		console.warn("[ArrayExtra.removeItem] Item not found.");
+		return array;
+	}
+	array.splice(index, 1);
+	return array;
+};
+
+export const removeItemByKey = (key: string, value: any, array: any[]) => {
+	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;
+};
+
+export const getRandom = (array: any[], n: number) => {
+	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
+ */
+export const getHalfRandom = (array: any[], n: number) => {
+	var n = Math.ceil(array.length / 2);
+	return getRandom(array, n);
+};
+
+/**
+ * Make array shuffle itself
+ */
+export const shuffle = (array: any[]) => {
+	var i = array.length,
+		j,
+		temp;
+
+	if (array.length < 1) 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: any[], oldIndex: number, newIndex: number) => {
+	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: any[], oldIndex: number, newIndex: number) => {
+	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/color.ts

@@ -0,0 +1,89 @@
+export const random = (hex = false) => {
+	return (hex ? "#" : "") + Math.floor(Math.random() * 16777215).toString(16);
+};
+
+// This function (pSBC) will take a HEX or RGB web color.
+// pSBC can shade it darker or lighter, or blend it with a second color, and can also pass it right thru but convert from Hex to RGB (Hex2RGB) or RGB to Hex (RGB2Hex).
+// All without you even knowing what color format you are using.
+// Version 4.0 (pref: https://github.com/PimpTrizkit/PJs/wiki/12.-Shade,-Blend-and-Convert-a-Web-Color-(pSBC.js));
+
+export const pSBC = (p: any, c0: any, c1?: any, l?: any) => {
+	let r,
+		g,
+		b,
+		P,
+		f,
+		t,
+		h,
+		i = parseInt,
+		m = Math.round,
+		a: any = typeof c1 == "string";
+	if (typeof p != "number" || p < -1 || p > 1 || typeof c0 != "string" || (c0[0] != "r" && c0[0] != "#") || (c1 && !a))
+		return null;
+
+	const pSBCr = (d: any) => {
+		let n = d.length,
+			x: { r: number; g: number; b: number; a: number } = { r: 0, g: 0, b: 0, a: 1 };
+		if (n > 9) {
+			([r, g, b, a] = d = d.split(",")), (n = d.length);
+			if (n < 3 || n > 4) return null;
+			(x.r = i(r[3] == "a" ? r.slice(5) : r.slice(4))),
+				(x.g = i(g)),
+				(x.b = i(b)),
+				(x.a = a ? parseFloat(a.toString()) : -1);
+		} else {
+			if (n == 8 || n == 6 || n < 4) return null;
+			if (n < 6) d = "#" + d[1] + d[1] + d[2] + d[2] + d[3] + d[3] + (n > 4 ? d[4] + d[4] : "");
+			d = i(d.slice(1), 16);
+			if (n == 9 || n == 5)
+				(x.r = (d >> 24) & 255), (x.g = (d >> 16) & 255), (x.b = (d >> 8) & 255), (x.a = m((d & 255) / 0.255) / 1000);
+			else (x.r = d >> 16), (x.g = (d >> 8) & 255), (x.b = d & 255), (x.a = -1);
+		}
+		return x;
+	};
+	(h = c0.length > 9),
+		(h = a ? (c1.length > 9 ? true : c1 == "c" ? !h : false) : h),
+		(f = pSBCr(c0)),
+		(P = p < 0),
+		(t = c1 && c1 != "c" ? pSBCr(c1) : P ? { r: 0, g: 0, b: 0, a: -1 } : { r: 255, g: 255, b: 255, a: -1 }),
+		(p = P ? p * -1 : p),
+		(P = 1 - p);
+	if (!f || !t || typeof f == "undefined") return null;
+	else if (l) (r = m(P * f.r + p * t.r)), (g = m(P * f.g + p * t.g)), (b = m(P * f.b + p * t.b));
+	else
+		(r = m((P * f.r ** 2 + p * t.r ** 2) ** 0.5)),
+			(g = m((P * f.g ** 2 + p * t.g ** 2) ** 0.5)),
+			(b = m((P * f.b ** 2 + p * t.b ** 2) ** 0.5));
+
+	(a = f.a), (t = t.a), (f = a >= 0 || t >= 0), (a = f ? (a < 0 ? t : t < 0 ? a : a * P + t * p) : 0);
+
+	if (h) return "rgb" + (f ? "a(" : "(") + r + "," + g + "," + b + (f ? "," + m(a * 1000) / 1000 : "") + ")";
+	else
+		return (
+			"#" +
+			(4294967296 + r * 16777216 + g * 65536 + b * 256 + (f ? m(a * 255) : 0)).toString(16).slice(1, f ? undefined : -2)
+		);
+};
+
+export const hexToRgb = (hex: string) => {
+	var result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+	return result
+		? {
+				r: parseInt(result[1], 16),
+				g: parseInt(result[2], 16),
+				b: parseInt(result[3], 16),
+		  }
+		: null;
+};
+
+export const hexDarken = (hex: string, amount: number) => {
+	return pSBC(-amount, hex);
+};
+
+export const hexLighten = (hex: string, amount: number) => {
+	return pSBC(amount, hex);
+};
+
+export const RGBToHex = (rgb: string | any) => {
+	return pSBC(0, rgb, "c", true);
+};

package/src/console/enableConsole.ts

@@ -0,0 +1,6 @@
+import cloneDeep from "lodash/cloneDeep";
+const _console = cloneDeep(console);
+
+export function enableConsole() {
+	return _console;
+}

package/src/console/index.ts

@@ -0,0 +1,11 @@
+export const disableConsole = (params: any) => {
+	for (var key in console) {
+		(console as any)[key] = function () {};
+	}
+};
+
+export const removeConsole = disableConsole;
+
+export const showCredit = (params: any) => {
+	console.log("Developed by Digitop | https://www.wearetopgroup.com/?utm_src=console");
+};

package/src/device/browser.ts

@@ -0,0 +1,29 @@
+export const isPotrait = () => {
+	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 = () => {
+	return !isPotrait();
+};
+
+export const ua = () => {
+	if (typeof navigator == "undefined") return null;
+	if (typeof window == "undefined") return null;
+
+	return navigator.userAgent || navigator.vendor || (window as any).opera;
+};
+
+export const isFacebookWebview = () => {
+	var ua: any = ua();
+	if (typeof ua != "undefined") return ua.indexOf("FBAN") > -1 || ua.indexOf("FBAV") > -1;
+};
+
+export const isInAppWebview = () => {
+	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;
+};

package/src/device/camera.ts

@@ -0,0 +1,209 @@
+import { requestCamera } from "../permission/requestCamera";
+
+type GetWebcamParams = {
+	container?: HTMLElement;
+	facingMode: string;
+	audio: boolean;
+};
+
+export function getWebcam(params: GetWebcamParams = { facingMode: "environment", audio: true }) {
+	if (typeof window == "undefined") return;
+
+	const { container, facingMode = "environment", audio = true } = params;
+	const _container = container || document.body;
+
+	return new Promise(async (resolve, reject) => {
+		const video = document.createElement("video");
+		video.style.position = "absolute";
+		video.style.top = "0";
+		video.style.left = "0";
+		video.style.width = "100%";
+		video.style.height = "100%";
+		_container.append(video);
+
+		let inputCameras: any[] = [];
+		let currentCamera: any;
+
+		const requestedMediaConstraints: MediaStreamConstraints = {
+			video: {
+				facingMode: { exact: facingMode },
+			},
+			audio,
+		};
+
+		let stream: any;
+		let isAllowed = false;
+
+		console.log("[Camera.js] Requesting:", requestedMediaConstraints);
+		const res = await requestCamera({ audio });
+		if (!res) {
+			setTimeout(function () {
+				handleError({ name: "Error", message: "NotSupported" });
+			}, 50);
+		}
+
+		// start requesting media permissions:
+
+		// console.log("[Camera.js] Requesting:", requestedMediaConstraints);
+
+		// if (navigator.mediaDevices.enumerateDevices === undefined) {
+		// 	setTimeout(function () {
+		// 		handleError({ name: "Error", message: "NotSupported" });
+		// 	}, 50);
+		// } else {
+		navigator.mediaDevices.enumerateDevices().then(parseDevices).catch(handleError);
+		// }
+
+		function parseDevices(devices: MediaDeviceInfo[]) {
+			inputCameras = [];
+			let backCameras: any[] = [];
+
+			devices.forEach(function (device) {
+				if (device.kind == "videoinput" && typeof device.deviceId != "undefined" && device.deviceId != "") {
+					inputCameras.push(device);
+				}
+			});
+			// //alert (JSON.stringify (devices));
+			console.log("[Camera.js] inputCameras:", inputCameras);
+
+			if (inputCameras.length > 0) {
+				let cams = "";
+				let backCamera: any;
+
+				inputCameras.map((cam, index) => {
+					cams += `[${cam.deviceId}] ${cam.kind} | ${cam.label}\n`;
+					// console.log(cam);
+					let label = cam.label.toLowerCase();
+					if (label.indexOf("back") > -1 || label.indexOf("facetime") > -1) {
+						backCamera = cam;
+						backCameras.push(backCamera);
+					}
+				});
+
+				if (backCameras.length > 1) {
+					backCamera = backCameras[backCameras.length - 1];
+				}
+
+				console.log(`[Camera.js] All input sources:`, cams);
+				console.log(
+					`[Camera.js] This device has ${backCameras.length} back camera${backCameras.length > 1 ? "s" : ""}.`
+				);
+				console.log("[Camera.js] backCameras:", JSON.stringify(backCameras));
+
+				currentCamera = backCamera;
+
+				// if (scope.onGotDevices) {
+				// 	scope.onGotDevices(devices);
+				// }
+
+				// Lấy stream của camera sau
+				// (Lấy cái cuối cùng trong danh sách trước, thường sẽ là camera chính trên Android)
+				getStreamOfCameraId(backCamera.deviceId)
+					.then(onStreamReceived)
+					.catch((e) => {
+						if (backCameras.length > 1) {
+							// nếu thiết bị có nhiều hơn 1 camera sau -> thử lấy camera khác
+							backCamera = backCameras[backCameras.length - 2];
+							getStreamOfCameraId(backCamera.deviceId).then(onStreamReceived).catch(handleError);
+						} else if (backCameras.length > 2) {
+							// nếu thiết bị có nhiều hơn 2 camera sau -> thử lấy camera khác nữa
+							backCamera = backCameras[backCameras.length - 3];
+							getStreamOfCameraId(backCamera.deviceId).then(onStreamReceived).catch(handleError);
+						} else {
+							// nếu thiết bị đéo có camera sau...
+							handleError(e);
+						}
+					});
+			} else {
+				navigator.mediaDevices.getUserMedia(requestedMediaConstraints).then(onStreamReceived).catch(handleError);
+
+				// if (scope.onGotDevicesFailed) scope.onGotDevicesFailed();
+			}
+		}
+
+		function onStreamReceived(stream: any): void {
+			if (inputCameras.length == 0) {
+				console.log("[Camera.js] Not found any back cameras, request again?");
+				navigator.mediaDevices.enumerateDevices().then(parseDevices).catch(handleError);
+				return;
+			}
+
+			isAllowed = true;
+
+			playWebcamVideo(stream);
+		}
+
+		function playWebcamVideo(_stream: any) {
+			stream = _stream;
+
+			if ("srcObject" in video) {
+				// //alert ('GOT STREAM VIDEO OBJECT');
+				video.srcObject = _stream;
+			} else {
+				// //alert ('GOT STREAM VIDEO SOURCE URL');
+				// Avoid using this in new browsers, as it is going away.
+				video.src = window.URL.createObjectURL(_stream);
+			}
+
+			// required to tell iOS safari we don't want fullscreen
+			video.setAttribute("playsinline", "true");
+			video.setAttribute("muted", "true");
+			video.setAttribute("autoplay", "true");
+			video.muted = true;
+			video.autoplay = true;
+			video.style.objectFit = "cover";
+			video.play();
+
+			// auto play
+			video.addEventListener("canplay", function (e) {
+				// //alert ('CAN PLAY');
+			});
+
+			video.addEventListener("canplaythrough", function (e) {
+				// //alert ('CAN PLAY THROUGH');
+			});
+
+			video.addEventListener("error", (e) => console.log("[Camera.js] <video> error:", e));
+
+			video.addEventListener("stalled", function (e) {
+				// //alert ('CANNOT GET METADATA');
+				isAllowed = false;
+				console.log("[Camera.js] <video> stalled:", e);
+
+				reject();
+			});
+
+			video.addEventListener("loadedmetadata", function (e) {
+				if (currentCamera.label.toLowerCase().indexOf("facetime") > -1) {
+					video.style.transform = "scaleX(-1)";
+					video.style.webkitTransform = "scaleX(-1)";
+				}
+
+				video.play();
+
+				resolve(video);
+			});
+		}
+
+		function getStreamOfCameraId(id: any) {
+			const constraints = {
+				video: { deviceId: { exact: id } },
+				audio: false,
+			};
+
+			return new Promise((resolve, reject) => {
+				navigator.mediaDevices.getUserMedia(constraints).then(resolve).catch(reject);
+			});
+		}
+
+		function handleError(err: any) {
+			console.error(err);
+			const errMsg = "[Camera.js] " + err.name + ": " + err.message;
+			console.error(errMsg);
+
+			isAllowed = false;
+
+			reject();
+		}
+	});
+}