@cocreate/utils 1.41.1 → 1.42.0

package/src/dataQuery.js

@@ -0,0 +1,291 @@
+import { getValueFromObject } from "./getValueFromObject.js";
+import { isValidDate } from "./isValidDate.js";
+
+function isEqualArray(arr1, arr2) {
+	if (arr1.length !== arr2.length) {
+		return false;
+	}
+	for (let i = 0; i < arr1.length; i++) {
+		if (!isEqualObject(arr1[i], arr2[i])) {
+			return false;
+		}
+	}
+	return true;
+}
+
+function isEqualObject(obj1, obj2) {
+	const keys1 = Object.keys(obj1);
+	const keys2 = Object.keys(obj2);
+
+	if (keys1.length !== keys2.length) {
+		return false;
+	}
+
+	for (const key of keys1) {
+		if (obj1[key] !== obj2[key]) {
+			return false;
+		}
+	}
+
+	return true;
+}
+
+function queryMatch(data, query) {
+	for (let key of Object.keys(query)) {
+		let dataValue;
+		try {
+			dataValue = getValueFromObject(data, key, true);
+		} catch (error) {
+			return false;
+		}
+
+		if (
+			typeof query[key] === "string" ||
+			typeof query[key] === "number" ||
+			typeof query[key] === "boolean"
+		) {
+			if (Array.isArray(dataValue)) return dataValue.includes(query[key]);
+			else return dataValue === query[key];
+		} else if (Array.isArray(query[key])) {
+			if (Array.isArray(dataValue)) {
+				return isEqualArray(dataValue, query[key]);
+			} else {
+				return false;
+			}
+		} else {
+			for (let property of Object.keys(query[key])) {
+				if (property === "$options") continue;
+				if (!property.startsWith("$")) {
+					if (typeof dataValue !== "object") {
+						return false;
+					} else
+						return queryMatch(
+							{ [property]: getValueFromObject(dataValue, property) },
+							{ [property]: query[key][property] }
+						);
+				} else {
+					let queryValue = query[key][property];
+					if (isValidDate(queryValue) && isValidDate(dataValue)) {
+						queryValue = new Date(queryValue);
+						dataValue = new Date(dataValue);
+					}
+					let queryStatus = false;
+					switch (property) {
+						case "$eq":
+							if (Array.isArray(dataValue) && Array.isArray(queryValue)) {
+								queryStatus = isEqualArray(dataValue, queryValue);
+							} else {
+								queryStatus = dataValue === queryValue;
+							}
+							break;
+						case "$ne":
+							if (Array.isArray(dataValue) && Array.isArray(queryValue)) {
+								queryStatus = !isEqualArray(dataValue, queryValue);
+							} else {
+								queryStatus = dataValue !== queryValue;
+							}
+							break;
+						case "$not":
+							queryStatus = !queryMatch(data, {
+								[key]: query[key]["$not"]
+							});
+							break;
+						case "$lt":
+							queryStatus = dataValue < queryValue;
+							break;
+						case "$lte":
+							queryStatus = dataValue <= queryValue;
+							break;
+						case "$gt":
+							queryStatus = dataValue > queryValue;
+							break;
+						case "$gte":
+							queryStatus = dataValue >= queryValue;
+							break;
+						case "$in":
+							if (Array.isArray(dataValue)) {
+								queryStatus = dataValue.some((element) =>
+									queryValue.includes(element)
+								);
+							} else {
+								queryStatus = queryValue.includes(dataValue);
+							}
+							break;
+						case "$nin":
+							if (Array.isArray(dataValue)) {
+								queryStatus = !dataValue.some((element) =>
+									queryValue.includes(element)
+								);
+							} else {
+								queryStatus = !queryValue.includes(dataValue);
+							}
+							break;
+						case "$all":
+							if (Array.isArray(dataValue) && Array.isArray(queryValue)) {
+								queryStatus = queryValue.every((element) =>
+									dataValue.includes(element)
+								);
+							}
+							break;
+						case "$elemMatch":
+							if (Array.isArray(data[key])) {
+								queryStatus = data[key].some((element) =>
+									queryMatch(element, query[key][property])
+								);
+							}
+							break;
+						case "$size":
+							if (Array.isArray(dataValue)) {
+								queryStatus = dataValue.length === queryValue;
+							}
+							break;
+						case "$exists":
+							queryStatus = queryValue
+								? data.hasOwnProperty(key)
+								: !data.hasOwnProperty(key);
+							break;
+						case "$regex":
+							if (typeof dataValue === "string") {
+								let regexFlag = query[key]["$options"] || "";
+								let regex = new RegExp(queryValue, regexFlag);
+								queryStatus = regex.test(dataValue);
+							}
+							break;
+						case "$type":
+							let dataType = typeof dataValue;
+							if (Array.isArray(dataValue)) {
+								dataType = "array";
+							}
+							queryStatus = dataType === queryValue;
+							break;
+						case "$mod":
+							if (
+								typeof dataValue === "number" &&
+								Array.isArray(queryValue) &&
+								queryValue.length === 2
+							) {
+								const [divisor, remainder] = queryValue;
+								queryStatus = dataValue % divisor === remainder;
+							}
+							break;
+						case "$where":
+							if (typeof queryValue === "function") {
+								try {
+								} catch (error) {
+									console.error(
+										"Error in queryData $where function:",
+										error
+									);
+								}
+							}
+							break;
+						default:
+							console.log("unknown operator");
+							break;
+					}
+					if (!queryStatus) return false;
+				}
+			}
+			return true;
+		}
+	}
+}
+
+export function queryData(data, query) {
+	if (query.$and) {
+		for (let i = 0; i < query.$and.length; i++) {
+			if (!queryData(data, query.$and[i])) return false;
+		}
+	}
+
+	if (query.$nor) {
+		for (let i = 0; i < query.$nor.length; i++) {
+			if (queryData(data, query.$nor[i])) return false;
+		}
+	}
+
+	for (let key of Object.keys(query)) {
+		if (key === "$and" || key === "$or") continue;
+		if (!queryMatch(data, { [key]: query[key] })) return false;
+	}
+
+	if (query.$or) {
+		for (let i = 0; i < query.$or.length; i++) {
+			if (queryData(data, query.$or[i])) return true;
+		}
+	}
+
+	return true;
+}
+
+export function searchData(data, search) {
+	if (!search) return true;
+	if (!Array.isArray(search)) search = [search];
+	for (let i = 0; i < search.length; i++) {
+		let searchValue = search[i].value;
+		if (!Array.isArray(searchValue)) searchValue = [searchValue];
+		for (let key in data) {
+			let value = data[key];
+			let status = false;
+			switch (typeof value) {
+				case "number":
+					value = value.toString();
+					break;
+				case "object":
+					value = JSON.stringify(value);
+					break;
+				case "function":
+					value = value.toString();
+					break;
+			}
+			if (search[i].caseSensitive != "true" || search[i].caseSensitive != true)
+				value = value.toLowerCase();
+
+			for (let i = 0; i < searchValue.length; i++) {
+				let searchString = searchValue[i];
+				if (
+					search[i].caseSensitive != "true" ||
+					search[i].caseSensitive != true
+				)
+					searchString = searchString.toLowerCase();
+
+				if (searchString === "" && search[i].operator === "and") {
+					if (value !== "") return false;
+				}
+
+				if (value.indexOf(searchString) > -1) status = true;
+
+				if (status) return true;
+				else if (search[i].operator == "and") return false;
+			}
+		}
+		if (search[i].value.length && search[i].operator == "or") return false;
+	}
+	return true;
+}
+
+export function sortData(data, sort) {
+	return data.sort((a, b) => {
+		for (let i = 0; i < sort.length; i++) {
+			let key = sort[i].key;
+			if (a[key] == null && b[key] == null) continue;
+			if (a[key] == null) return sort[i].direction === "desc" ? -1 : 1;
+			if (b[key] == null) return sort[i].direction === "desc" ? 1 : -1;
+
+			if (typeof a[key] !== typeof b[key]) {
+				return typeof a[key] < typeof b[key] ? -1 : 1;
+			}
+
+			if (a[key] !== b[key]) {
+				if (typeof a[key] === "string") {
+					return sort[i].direction === "desc"
+						? b[key].localeCompare(a[key])
+						: a[key].localeCompare(b[key]);
+				} else {
+					return sort[i].direction === "desc" ? b[key] - a[key] : a[key] - b[key];
+				}
+			}
+		}
+		return 0;
+	});
+}

package/src/dom.js

@@ -0,0 +1,4 @@
+export { domParser } from "./domParser.js";
+export { parseTextToHtml } from "./parseTextToHtml.js";
+export { escapeHtml } from "./escapeHtml.js";
+export { cssPath } from "./cssPath.js";

package/src/domParser.js

@@ -0,0 +1,21 @@
+export function domParser(str) {
+	try {
+		var mainTag = str.match(/\<(?<tag>[a-z0-9]+)(.*?)?\>/).groups.tag;
+	} catch (e) {}
+	let doc;
+	switch (mainTag) {
+		case "html":
+			doc = new DOMParser().parseFromString(str, "text/html");
+			return doc.documentElement;
+		case "body":
+			doc = new DOMParser().parseFromString(str, "text/html");
+			return doc.body;
+		case "head":
+			doc = new DOMParser().parseFromString(str, "text/html");
+			return doc.head;
+		default:
+			let con = document.createElement("dom-parser");
+			con.innerHTML = str;
+			return con;
+	}
+}

package/src/dotNotationToObject.js

@@ -0,0 +1,90 @@
+export function dotNotationToObject(data, obj = {}) {
+	try {
+		let arrayGroup = {};
+
+		for (const key of Object.keys(data)) {
+			let value = data[key];
+			let newObject = obj;
+			let oldObject = new Object(obj);
+			let keys = key.split(".");
+			let length = keys.length - 1;
+
+			for (let i = 0; i < keys.length; i++) {
+				if (keys[i].endsWith("]")) {
+					if (keys[i].endsWith("[]")) {
+						let baseKey = keys[i].slice(0, -2);
+
+						if (!Array.isArray(newObject[baseKey])) {
+							newObject[baseKey] = [];
+						}
+
+						if (length == i) {
+							if (Array.isArray(value)) {
+								newObject[baseKey].push(...value);
+							} else {
+								newObject[baseKey].push(value);
+							}
+						}
+					} else if (/\[([0-9]+)\]/g.test(keys[i])) {
+						let [k, index] = keys[i].split("[");
+						index = index.slice(0, -1);
+
+						if (!Array.isArray(newObject[k])) {
+							newObject[k] = [];
+						}
+
+						if (length == i) {
+							if (value === undefined) {
+								newObject[k].splice(index, 1);
+							} else {
+								newObject[k][index] = value;
+							}
+						} else {
+							newObject[k][index] = oldObject[k][index] || {};
+							newObject = newObject[k][index];
+							oldObject = oldObject[k][index];
+						}
+					} else if (/\[\w\]/g.test(keys[i])) {
+						let [k, group] = keys[i].split("[");
+						group = group.slice(0, -1);
+
+						if (!Array.isArray(newObject[k])) {
+							newObject[k] = [];
+						}
+
+						let index;
+						if (arrayGroup[keys.slice(0, i + 1).join(".")]) {
+							index = arrayGroup[keys.slice(0, i + 1).join(".")];
+						} else {
+							index = newObject[k].length;
+							arrayGroup[keys.slice(0, i + 1).join(".")] = index;
+							newObject[k][index] = {};
+						}
+
+						if (length == i) {
+							newObject[k][index] = value;
+						} else {
+							newObject = newObject[k][index];
+						}
+					}
+				} else {
+					if (length == i) {
+						if (value === undefined) {
+							delete newObject[keys[i]];
+						} else {
+							newObject[keys[i]] = value;
+						}
+					} else {
+						newObject[keys[i]] = oldObject[keys[i]] || {};
+						newObject = newObject[keys[i]];
+						oldObject = oldObject[keys[i]];
+					}
+				}
+			}
+		}
+		return obj;
+	} catch (error) {
+		console.log("Error converting dot notation to object", error);
+		return false;
+	}
+}

package/src/escapeHtml.js

@@ -0,0 +1,8 @@
+export function escapeHtml(html) {
+	return html
+		.replaceAll("&", "&amp")
+		.replaceAll("<", "&lt")
+		.replaceAll(">", "&gt;")
+		.replaceAll("'", "&#39;")
+		.replaceAll('"', "&quot;");
+}

package/src/getRelativePath.js

@@ -0,0 +1,24 @@
+export function getRelativePath(path) {
+	const isBrowser = typeof window !== "undefined";
+
+	if (!path && isBrowser) {
+		path = window.location.pathname.replace(/\/[^\/]*$/, "");
+	}
+
+	if (
+		isBrowser &&
+		(location.hostname === "localhost" ||
+			location.hostname === "127.0.0.1")
+	) {
+		const srcIndex = path.indexOf("/src");
+		if (srcIndex !== -1) {
+			path = path.slice(srcIndex + 4);
+		}
+	}
+
+	if (!path.endsWith("/")) {
+		path += "/";
+	}
+	let depth = path.split("/").filter(Boolean).length;
+	return depth > 0 ? "../".repeat(depth) : "./";
+}

package/src/getValueFromObject.js

@@ -0,0 +1,25 @@
+export function getValueFromObject(object = {}, path = "", throwError = false) {
+	try {
+		if ((!Array.isArray(object) && !Object.keys(object).length) || !path) {
+			if (throwError) throw new Error("Invalid input to getValueFromObject");
+			return;
+		}
+
+		path = path.replace(/\[(\d+)\]/g, ".$1").replace(/^\./, "");
+
+		let data = object,
+			subpath = path.split(".");
+
+		for (let i = 0; i < subpath.length; i++) {
+			if (throwError && !(subpath[i] in data))
+				throw new Error("Key not found in object: " + subpath[i]);
+
+			data = data[subpath[i]];
+			if (!data) break;
+		}
+
+		return data;
+	} catch (error) {
+		if (throwError) throw error;
+	}
+}