@cocreate/utils 1.41.1 → 1.42.0

package/src/queryElements.js

@@ -0,0 +1,174 @@
+const queryTypes = [
+	"$closest",
+	"$parent",
+	"$next",
+	"$previous",
+	"$document",
+	"$frame",
+	"$top"
+];
+
+const regexPatternString = `(?:${queryTypes
+	.map((type) => type.replace("$", "\\$"))
+	.join("|")})`;
+
+const queryTypesRegex = new RegExp(regexPatternString);
+
+const mediaRanges = {
+	xs: [0, 575],
+	sm: [576, 768],
+	md: [769, 992],
+	lg: [993, 1200],
+	xl: [1201, 0]
+};
+
+export function checkMediaQueries(selector) {
+	if (selector && selector.includes("@")) {
+		const viewportWidth = window.innerWidth;
+		let mediaViewport = false;
+
+		let screenSizes = selector.split("@");
+		selector = screenSizes.shift();
+
+		for (let screenSize of screenSizes) {
+			if (mediaRanges.hasOwnProperty(screenSize)) {
+				const [minWidth, maxWidth] = mediaRanges[screenSize];
+				if (viewportWidth >= minWidth && viewportWidth <= maxWidth) {
+					mediaViewport = true;
+					break;
+				}
+			}
+		}
+		if (!mediaViewport) return false;
+	}
+
+	return selector;
+}
+
+function queryType(element, type) {
+	if (!element) return null;
+
+	switch (type) {
+		case "$top":
+			return window.top.document;
+		case "$frame":
+			if (element.nodeType === 9) return window.frameElement;
+			return element;
+		case "$document":
+			return element.nodeType === 9 ? element : element.ownerDocument;
+		case "$closest":
+			return element.nodeType === 9 ? element : element.ownerDocument;
+		case "$parent":
+			if (element.nodeType === 9) {
+				return element.defaultView !== window.top
+					? element.defaultView.parent.document
+					: null;
+			}
+			return element.parentElement;
+		case "$next":
+			return element.nextElementSibling;
+		case "$previous":
+			return element.previousElementSibling;
+		default:
+			return null;
+	}
+}
+
+function querySelector(element, selector) {
+	if (!element) return null;
+	return selector.endsWith("[]")
+		? element.querySelectorAll(selector.slice(0, -2))
+		: element.querySelector(selector);
+}
+
+export function queryElements({ element = document, prefix, selector }) {
+	try {
+		let elements = new Set();
+
+		if (!selector && element.nodeType === 1) {
+			if (!prefix) {
+				for (let attr of element.attributes) {
+					if (attr.name.endsWith("-query") || attr.name.endsWith(".query")) {
+						prefix = attr.name.slice(0, -6);
+					}
+				}
+				if (!prefix) return [];
+			}
+			selector =
+				element.getAttribute(prefix + "-" + "query") ||
+				element.getAttribute(prefix + "." + "query");
+			if (!selector) return [];
+		}
+
+		let selectors = selector.split(/,(?![^()\[\]]*[)\]])/g);
+		for (let i = 0; i < selectors.length; i++) {
+			if (!selectors[i]) continue;
+
+			let queriedElement = element;
+
+			if (selectors[i].includes("@")) {
+				selectors[i] = checkMediaQueries(selectors[i]);
+				if (selectors[i] === false) continue;
+			}
+
+			let remainingSelector = selectors[i].trim();
+			let match;
+
+			while ((match = queryTypesRegex.exec(remainingSelector)) !== null) {
+				const matchIndex = match.index;
+				const operator = match[0];
+
+				const part = remainingSelector
+					.substring(0, matchIndex)
+					.trim()
+					.replace(/,$/, "");
+				if (part) {
+					queriedElement = querySelector(queriedElement, part);
+					if (!queriedElement) break;
+				}
+
+				remainingSelector = remainingSelector
+					.substring(matchIndex + operator.length)
+					.trim();
+
+				if (operator === "$closest") {
+					let [closest, remaining = ""] = remainingSelector.split(/\s+/, 2);
+					queriedElement = queriedElement.closest(closest);
+					remainingSelector = remaining.trim();
+				} else {
+					queriedElement = queryType(queriedElement, operator);
+				}
+
+				if (!queriedElement) break;
+			}
+
+			if (!queriedElement) continue;
+
+			if (remainingSelector) {
+				queriedElement = querySelector(queriedElement, remainingSelector);
+			}
+
+			if (
+				Array.isArray(queriedElement) ||
+				queriedElement instanceof HTMLCollection ||
+				queriedElement instanceof NodeList
+			) {
+				for (let el of queriedElement) {
+					if (el instanceof Element) {
+						elements.add(el);
+					}
+				}
+			} else if (queriedElement instanceof Element) {
+				elements.add(queriedElement);
+			}
+		}
+
+		return Array.from(elements);
+	} catch (e) {
+		console.error(
+			`CoCreate: Error in queryElements with selector: "${selector}".`,
+			e
+		);
+		return [];
+	}
+}

package/src/safeParse.js

@@ -0,0 +1,171 @@
+const constants = { PI: Math.PI, E: Math.E };
+
+const functions = {
+	abs: Math.abs,
+	ceil: Math.ceil,
+	floor: Math.floor,
+	round: Math.round,
+	max: Math.max,
+	min: Math.min,
+	pow: Math.pow,
+	sqrt: Math.sqrt,
+	log: Math.log,
+	sin: Math.sin,
+	cos: Math.cos,
+	tan: Math.tan
+};
+
+export function safeParse(expression, context = {}) {
+	if (typeof expression !== "string") {
+		expression = String(expression);
+	}
+
+	let currentExpr = expression.trim();
+	if (!currentExpr) return null;
+
+	const tokenizerRegex =
+		/('[^']*'|"[^"]*"|\d+(?:\.\d+)?|>=|<=|===|!==|==|!=|&&|\|\||[a-zA-Z_][a-zA-Z0-9_\.]*|[\+\-\*\/\%\(\)\?\:\>\<\!\,\=])/g;
+
+	const tokens = currentExpr.match(tokenizerRegex) || [];
+	let pos = 0;
+
+	function peek() {
+		return tokens[pos];
+	}
+	function consume() {
+		return tokens[pos++];
+	}
+
+	function parse() {
+		return parseTernary();
+	}
+
+	function parseTernary() {
+		let left = parseLogical();
+		if (peek() === "?") {
+			consume();
+			let trueExpr = parseTernary();
+			if (peek() === ":") {
+				consume();
+				let falseExpr = parseTernary();
+				return left ? trueExpr : falseExpr;
+			}
+		}
+		return left;
+	}
+
+	function parseLogical() {
+		let left = parseComparison();
+		while (peek() === "&&" || peek() === "||") {
+			let op = consume();
+			let right = parseComparison();
+			if (op === "&&") left = left && right;
+			if (op === "||") left = left || right;
+		}
+		return left;
+	}
+
+	function parseComparison() {
+		let left = parseAdditive();
+		while ([">", "<", ">=", "<=", "===", "!==", "==", "!="].includes(peek())) {
+			let op = consume();
+			let right = parseAdditive();
+			if (op === ">") left = left > right;
+			if (op === "<") left = left < right;
+			if (op === ">=") left = left >= right;
+			if (op === "<=") left = left <= right;
+			if (op === "===") left = left === right;
+			if (op === "!==") left = left !== right;
+			if (op === "==") left = left == right;
+			if (op === "!=") left = left != right;
+		}
+		return left;
+	}
+
+	function parseAdditive() {
+		let left = parseMultiplicative();
+		while (["+", "-"].includes(peek())) {
+			let op = consume();
+			let right = parseMultiplicative();
+			if (op === "+") left = left + right;
+			if (op === "-") left = left - right;
+		}
+		return left;
+	}
+
+	function parseMultiplicative() {
+		let left = parsePrimary();
+		while (["*", "/", "%"].includes(peek())) {
+			let op = consume();
+			let right = parsePrimary();
+			if (op === "*") left = left * right;
+			if (op === "/") left = left / right;
+			if (op === "%") left = left % right;
+		}
+		return left;
+	}
+
+	function parsePrimary() {
+		let token = consume();
+		if (!token) return undefined;
+
+		if (/^\d/.test(token)) return parseFloat(token);
+
+		if (token.startsWith("'") || token.startsWith('"')) {
+			return token.slice(1, -1);
+		}
+
+		if (token === "true") return true;
+		if (token === "false") return false;
+
+		if (token === "(") {
+			let expr = parse();
+			if (peek() === ")") consume();
+			return expr;
+		}
+
+		if (token === "-") return -parsePrimary();
+		if (token === "!") return !parsePrimary();
+
+		if (constants.hasOwnProperty(token)) {
+			return constants[token];
+		}
+
+		if (peek() === "(" && functions.hasOwnProperty(token)) {
+			consume();
+			let args = [];
+			if (peek() !== ")") {
+				args.push(parse());
+				while (peek() === ",") {
+					consume();
+					args.push(parse());
+				}
+			}
+			if (peek() === ")") consume();
+
+			return functions[token](...args);
+		}
+
+		let path = token.split(".");
+		let val = context;
+		for (let part of path) {
+			if (val !== null && typeof val === "object" && part in val) {
+				val = val[part];
+			} else {
+				return undefined;
+			}
+		}
+		return val;
+	}
+
+	try {
+		const result = parse();
+		return result !== undefined ? result : null;
+	} catch (error) {
+		console.warn(
+			`Unexpected parsing error: ${error.message} (Expression context: "${expression}")`,
+			error
+		);
+		return null;
+	}
+}

package/src/uid.js

@@ -0,0 +1,16 @@
+export function uid(length = 36) {
+	let pattern = "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx";
+	if (length > 36) {
+		length = 36;
+	}
+
+	let uuid = pattern
+		.replace(/[xy]/g, function (c) {
+			var r = (Math.random() * 16) | 0;
+			var v = c === "x" ? r : (r & 0x3) | 0x8;
+			return v.toString(16);
+		})
+		.substring(0, length);
+
+	return uuid;
+}