@cocreate/utils 1.41.1 → 1.42.0

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+# [1.42.0](https://github.com/CoCreate-app/CoCreate-utils/compare/v1.41.2...v1.42.0) (2026-03-01)
+
+
+### Features
+
+* add utility functions for date validation and operator processing ([6649ca4](https://github.com/CoCreate-app/CoCreate-utils/commit/6649ca45218adafa14030e998c8a004da30a9397))
+
+## [1.41.2](https://github.com/CoCreate-app/CoCreate-utils/compare/v1.41.1...v1.41.2) (2026-02-28)
+
+
+### Bug Fixes
+
+* root factory variable Module ([c723787](https://github.com/CoCreate-app/CoCreate-utils/commit/c7237877d833976c821eeb322fd18b3e92f7fd37))
+
 ## [1.41.1](https://github.com/CoCreate-app/CoCreate-utils/compare/v1.41.0...v1.41.1) (2026-02-04)
 
 

package/README.md

@@ -31,11 +31,46 @@ For a complete guide and working demo refer to the [doumentation](https://cocrea
 $ npm i @cocreate/utils
 ```
 
-## yarn
-
-```shell
-$ yarn install @cocreate/utils
-```
+## yarn
+
+```shell
+$ yarn install @cocreate/utils
+```
+
+## Module Usage
+
+### ESM (tree-shaking)
+
+```js
+import { uid, ObjectId } from "@cocreate/utils";
+```
+
+### ESM subpath imports
+
+```js
+import { getValueFromObject } from "@cocreate/utils/getValueFromObject";
+import { queryElements } from "@cocreate/utils/queryElements";
+```
+
+### CommonJS (Node)
+
+```js
+const { uid, ObjectId } = require("@cocreate/utils");
+const { getValueFromObject } = require("@cocreate/utils/getValueFromObject");
+```
+
+## Build
+
+```shell
+# Build UMD + ESM + CJS
+npm run build
+
+# Build only module outputs
+npm run build:modules
+
+# Build only UMD bundle
+npm run build:umd
+```
 
 # Table of Contents
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cocreate/utils",
-  "version": "1.41.1",
+  "version": "1.42.0",
   "description": "A simple utils component in vanilla javascript. Easily configured using HTML5 attributes and/or JavaScript API.",
   "keywords": [
     "utils",
@@ -17,7 +17,11 @@
   },
   "scripts": {
     "start": "npx webpack --config webpack.config.js",
-    "build": "npx webpack --mode=production --config webpack.config.js",
+    "build:umd": "npx webpack --mode=production --config webpack.config.js",
+    "build:modules:esm": "npx esbuild src/*.js --outdir=dist/esm --format=esm --target=es2017 && node -e \"require('fs').writeFileSync('dist/esm/package.json', '{\\n  \\\"type\\\": \\\"module\\\"\\n}\\n')\"",
+    "build:modules:cjs": "npx esbuild src/*.js --outdir=dist/cjs --format=cjs --target=node18",
+    "build:modules": "npm run build:modules:esm && npm run build:modules:cjs",
+    "build": "npm run build:umd && npm run build:modules",
     "dev": "npx webpack --config webpack.config.js --watch",
     "postinstall": "node -e \"const { execSync } = require('child_process'); try { execSync('coc --version', { stdio: 'ignore' }); } catch (error) { try { execSync('npm install -g @cocreate/cli', { stdio: 'inherit' }); console.log('Installed \"@cocreate/cli\" globally.'); } catch (error) { console.error('Failed to install \"@cocreate/cli\" globally:', error); } }\""
   },
@@ -35,7 +39,129 @@
     "type": "GitHub Sponsors ❤",
     "url": "https://github.com/sponsors/CoCreate-app"
   },
-  "main": "./src/index.js",
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/esm/index.js",
+  "exports": {
+    ".": {
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.js"
+    },
+    "./getRelativePath": {
+      "import": "./dist/esm/getRelativePath.js",
+      "require": "./dist/cjs/getRelativePath.js"
+    },
+    "./ObjectId": {
+      "import": "./dist/esm/ObjectId.js",
+      "require": "./dist/cjs/ObjectId.js"
+    },
+    "./uid": {
+      "import": "./dist/esm/uid.js",
+      "require": "./dist/cjs/uid.js"
+    },
+    "./checkValue": {
+      "import": "./dist/esm/checkValue.js",
+      "require": "./dist/cjs/checkValue.js"
+    },
+    "./isValidDate": {
+      "import": "./dist/esm/isValidDate.js",
+      "require": "./dist/cjs/isValidDate.js"
+    },
+    "./objectToSearchParams": {
+      "import": "./dist/esm/objectToSearchParams.js",
+      "require": "./dist/cjs/objectToSearchParams.js"
+    },
+    "./dotNotationToObject": {
+      "import": "./dist/esm/dotNotationToObject.js",
+      "require": "./dist/cjs/dotNotationToObject.js"
+    },
+    "./objectToDotNotation": {
+      "import": "./dist/esm/objectToDotNotation.js",
+      "require": "./dist/cjs/objectToDotNotation.js"
+    },
+    "./getValueFromObject": {
+      "import": "./dist/esm/getValueFromObject.js",
+      "require": "./dist/cjs/getValueFromObject.js"
+    },
+    "./createUpdate": {
+      "import": "./dist/esm/createUpdate.js",
+      "require": "./dist/cjs/createUpdate.js"
+    },
+    "./domParser": {
+      "import": "./dist/esm/domParser.js",
+      "require": "./dist/cjs/domParser.js"
+    },
+    "./parseTextToHtml": {
+      "import": "./dist/esm/parseTextToHtml.js",
+      "require": "./dist/cjs/parseTextToHtml.js"
+    },
+    "./escapeHtml": {
+      "import": "./dist/esm/escapeHtml.js",
+      "require": "./dist/cjs/escapeHtml.js"
+    },
+    "./cssPath": {
+      "import": "./dist/esm/cssPath.js",
+      "require": "./dist/cjs/cssPath.js"
+    },
+    "./queryElements": {
+      "import": "./dist/esm/queryElements.js",
+      "require": "./dist/cjs/queryElements.js"
+    },
+    "./checkMediaQueries": {
+      "import": "./dist/esm/queryElements.js",
+      "require": "./dist/cjs/queryElements.js"
+    },
+    "./queryData": {
+      "import": "./dist/esm/dataQuery.js",
+      "require": "./dist/cjs/dataQuery.js"
+    },
+    "./searchData": {
+      "import": "./dist/esm/dataQuery.js",
+      "require": "./dist/cjs/dataQuery.js"
+    },
+    "./sortData": {
+      "import": "./dist/esm/dataQuery.js",
+      "require": "./dist/cjs/dataQuery.js"
+    },
+    "./getAttributes": {
+      "import": "./dist/esm/attributes.js",
+      "require": "./dist/cjs/attributes.js"
+    },
+    "./getAttributeNames": {
+      "import": "./dist/esm/attributes.js",
+      "require": "./dist/cjs/attributes.js"
+    },
+    "./setAttributeNames": {
+      "import": "./dist/esm/attributes.js",
+      "require": "./dist/cjs/attributes.js"
+    },
+    "./safeParse": {
+      "import": "./dist/esm/safeParse.js",
+      "require": "./dist/cjs/safeParse.js"
+    },
+    "./processOperators": {
+      "import": "./dist/esm/operators.js",
+      "require": "./dist/cjs/operators.js"
+    },
+    "./processOperatorsAsync": {
+      "import": "./dist/esm/operators.js",
+      "require": "./dist/cjs/operators.js"
+    },
+    "./clickedElement": {
+      "import": "./dist/esm/clickedElement.js",
+      "require": "./dist/cjs/clickedElement.js"
+    },
+    "./init-browser": {
+      "import": "./dist/esm/init-browser.js",
+      "require": "./dist/cjs/init-browser.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "sideEffects": [
+    "./dist/esm/init-browser.js",
+    "./dist/cjs/init-browser.js",
+    "./dist/CoCreate-utils.js",
+    "./dist/CoCreate-utils.min.js"
+  ],
   "devDependencies": {
     "css-loader": "^5.1.3",
     "esbuild": "^0.25.2",

package/src/ObjectId.js

@@ -0,0 +1,41 @@
+let counter = 0;
+
+export function ObjectId(inputId) {
+	if (inputId && /^[0-9a-fA-F]{24}$/.test(inputId)) {
+		return {
+			timestamp: inputId.substring(0, 8),
+			processId: inputId.substring(8, 20),
+			counter: inputId.substring(20),
+			toString: function () {
+				return this.timestamp + this.processId + this.counter;
+			}
+		};
+	} else if (inputId) {
+		throw new Error("Invalid ObjectId provided.");
+	}
+
+	const timestampHex = Math.floor(
+		new Date(new Date().toISOString()).getTime() / 1000
+	)
+		.toString(16)
+		.padStart(8, "0");
+	const processIdHex = Math.floor(Math.random() * 0x100000000000)
+		.toString(16)
+		.padStart(12, "0");
+
+	counter = (counter + 1) % 10000;
+	if (counter < 2) {
+		counter = Math.floor(Math.random() * (5000 - 100 + 1)) + 100;
+	}
+
+	const counterHex = counter.toString(16).padStart(4, "0");
+
+	return {
+		timestamp: timestampHex,
+		processId: processIdHex,
+		counter: counterHex,
+		toString: function () {
+			return this.timestamp + this.processId + this.counter;
+		}
+	};
+}

package/src/attributes.js

@@ -0,0 +1,48 @@
+export function getAttributes(el) {
+	if (!el) return;
+
+	let attributes = window.CoCreateConfig.attributes;
+	let object = {};
+
+	for (let attribute of el.attributes) {
+		let variable = attributes[attribute.name];
+		if (variable) {
+			object[variable] = el.getAttribute(attribute.name);
+		}
+	}
+
+	return object;
+}
+
+export function getAttributeNames(variables) {
+	let reversedObject = {};
+	for (const key of Object.keys(CoCreateConfig.attributes)) {
+		reversedObject[CoCreateConfig.attributes[key]] = key;
+	}
+
+	let attributes = [];
+	for (const variable of variables) {
+		let attribute = reversedObject[variable];
+		if (attribute) attributes.push(attribute);
+	}
+	return attributes;
+}
+
+export function setAttributeNames(attributes, overWrite) {
+	let reversedObject = {};
+	for (const key of Object.keys(CoCreateConfig.attributes)) {
+		reversedObject[CoCreateConfig.attributes[key]] = key;
+	}
+
+	for (const attribute of Object.keys(attributes)) {
+		const variable = attributes[attribute];
+		if (!reversedObject[variable] || overWrite != false)
+			reversedObject[variable] = attribute;
+	}
+
+	let revertObject = {};
+	for (const key of Object.keys(reversedObject)) {
+		revertObject[reversedObject[key]] = key;
+	}
+	CoCreateConfig.attributes = revertObject;
+}

package/src/checkValue.js

@@ -0,0 +1,4 @@
+export function checkValue(value) {
+	if (/{{\s*([\w\W]+)\s*}}/g.test(value)) return false;
+	else return true;
+}

package/src/clickedElement.js

@@ -0,0 +1,28 @@
+export function clickedElement() {
+	document.addEventListener("click", (e) => {
+		document.clickedElement = e.target;
+	});
+
+	try {
+		let frames = document.querySelectorAll("iframe");
+		for (let frame of frames) {
+			try {
+				let frameDocument = frame.contentDocument;
+				if (!frameDocument.clickedElementListenerAdded) {
+					frameDocument.addEventListener("click", (e) => {
+						frameDocument.clickedElement = e.target;
+					});
+
+					frameDocument.clickedElementListenerAdded = true;
+				}
+			} catch (iframeError) {
+				console.log(
+					`Cross-origin frame handling failed for: ${frame}`,
+					iframeError
+				);
+			}
+		}
+	} catch (e) {
+		console.log("Top-level frame document handling failed:", e);
+	}
+}

package/src/core.js

@@ -0,0 +1,6 @@
+export { getRelativePath } from "./getRelativePath.js";
+export { ObjectId } from "./ObjectId.js";
+export { uid } from "./uid.js";
+export { checkValue } from "./checkValue.js";
+export { isValidDate } from "./isValidDate.js";
+export { objectToSearchParams } from "./objectToSearchParams.js";

package/src/createUpdate.js

@@ -0,0 +1,202 @@
+import { dotNotationToObject } from "./dotNotationToObject.js";
+import { objectToDotNotation } from "./objectToDotNotation.js";
+import { getValueFromObject } from "./getValueFromObject.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 dotNotationToObjectUpdate(data, object = {}) {
+	try {
+		for (const key of Object.keys(data)) {
+			let newObject = object;
+			let keys = key
+				.replace(/\[(\d+)\]/g, ".$1")
+				.split(".")
+				.map((k) => (isNaN(k) ? k : Number(k)));
+			let value = data[key];
+			let operator;
+			if (keys[0].startsWith("$")) operator = keys.shift();
+
+			let length = keys.length - 1;
+			for (let i = 0; i < keys.length; i++) {
+				if (length == i) {
+					if (operator) {
+						let operators = [
+							"$rename",
+							"$inc",
+							"$push",
+							"$each",
+							"$splice",
+							"$unset",
+							"$delete",
+							"$slice",
+							"$pop",
+							"$shift",
+							"$addToSet",
+							"$pull"
+						];
+						if (!operators.includes(operator)) continue;
+						if (operator === "$rename") {
+							newObject[value] = newObject[keys[i]];
+							delete newObject[keys[i]];
+						} else if (
+							operator === "$delete" ||
+							operator === "$unset" ||
+							operator === "$slice"
+						) {
+							if (typeof keys[i] === "number") {
+								newObject.splice(keys[i], 1);
+							} else {
+								delete newObject[keys[i]];
+							}
+						} else if (operator === "$shift") {
+							newObject[keys[i]].shift();
+						} else if (operator === "$pop") {
+							newObject[keys[i]].pop();
+						} else if (operator === "$addToSet") {
+							if (!newObject[keys[i]]) newObject[keys[i]] = [];
+							let exists;
+							if (Array.isArray(value)) {
+								exists = newObject[keys[i]].some(
+									(item) => Array.isArray(item) && isEqualArray(item, value)
+								);
+							} else if (
+								typeof value === "object" &&
+								value !== null
+							) {
+								exists = newObject[keys[i]].some(
+									(item) =>
+										typeof item === "object" && isEqualObject(item, value)
+								);
+							} else {
+								exists = newObject[keys[i]].includes(value);
+							}
+							if (!exists) newObject[keys[i]].push(value);
+						} else if (operator === "$pull") {
+							if (!newObject[keys[i]]) continue;
+							if (Array.isArray(value)) {
+								newObject[keys[i]] = newObject[keys[i]].filter(
+									(item) => !Array.isArray(item) || !isEqualArray(item, value)
+								);
+							} else if (
+								typeof value === "object" &&
+								value !== null
+							) {
+								newObject[keys[i]] = newObject[keys[i]].filter(
+									(item) =>
+										typeof item !== "object" || !isEqualObject(item, value)
+								);
+							} else {
+								newObject[keys[i]] = newObject[keys[i]].filter(
+									(item) => item !== value
+								);
+							}
+						} else if (operator === "$push" || operator === "$splice") {
+							if (
+								typeof keys[i] === "number" &&
+								newObject.length >= keys[i]
+							)
+								newObject.splice(keys[i], 0, value);
+							else if (newObject[keys[i]]) newObject[keys[i]].push(value);
+							else newObject[keys[i]] = [value];
+						} else if (operator === "$each") {
+							if (!Array.isArray(value)) value = [value];
+							if (typeof keys[i] === "number")
+								newObject.splice(keys[i], 0, ...value);
+							else newObject[keys[i]].push(...value);
+						} else if (operator === "$inc") {
+							if (
+								!newObject[keys[i]] ||
+								typeof newObject[keys[i]] !== "number"
+							)
+								newObject[keys[i]] = value;
+							else newObject[keys[i]] += value;
+						}
+					} else if (value === undefined) {
+						if (typeof keys[i] === "number") newObject.splice(keys[i], 1);
+						else delete newObject[keys[i]];
+					} else if (typeof keys[i] === "number") {
+						newObject.splice(keys[i], 0, value);
+					} else {
+						newObject[keys[i]] = value;
+					}
+				} else if (
+					typeof keys[i + 1] === "number" &&
+					!Array.isArray(newObject[keys[i]])
+				) {
+					newObject[keys[i]] = [];
+				} else {
+					newObject[keys[i]] = newObject[keys[i]] || {};
+				}
+				newObject = newObject[keys[i]];
+			}
+		}
+		return object;
+	} catch (error) {
+		console.log("Error converting dot notation to object", error);
+		return false;
+	}
+}
+
+export function createUpdate(update, data, globalOpertors) {
+	let operatorKeys = {};
+	if (globalOpertors) operatorKeys = { ...globalOpertors };
+
+	Object.keys(data).forEach((key) => {
+		if (key.startsWith("$")) {
+			if (!key.includes("."))
+				for (let oldkey of Object.keys(data[key]))
+					operatorKeys[key + "." + oldkey] = data[key][oldkey];
+			else operatorKeys[key] = data[key];
+		} else if (
+			typeof data[key] === "string" &&
+			data[key].startsWith("$")
+		) {
+			operatorKeys[data[key] + "." + key] = data[key];
+		} else if (key.endsWith("]")) {
+			const regex = /^(.*(?:\[\d+\].*?)?)\[(.*?)\](?:\[\])?$/;
+			const match = key.match(regex);
+			if (match[2] === "") operatorKeys["$push." + match[1]] = data[key];
+			else {
+				let index = parseInt(match[2], 10);
+				if (Number.isNaN(index))
+					operatorKeys[match[2] + "." + match[1]] = data[key];
+				else operatorKeys[key] = data[key];
+			}
+		} else if (key.includes(".")) {
+			operatorKeys[key] = data[key];
+		} else if (data[key] === undefined) {
+			delete update[key];
+		} else update[key] = data[key];
+	});
+
+	return dotNotationToObjectUpdate(operatorKeys, update);
+}
+
+export { dotNotationToObject, objectToDotNotation, getValueFromObject };

package/src/cssPath.js

@@ -0,0 +1,50 @@
+export function cssPath(node, container) {
+	let pathSplits = [];
+	do {
+		if (!node || !node.tagName) return false;
+		let pathSplit = node.tagName.toLowerCase();
+
+		if (node.id) {
+			pathSplit += "#" + node.id;
+			node = "";
+		} else {
+			let eid = node.getAttribute("eid");
+			if (eid && !/{{\s*([\w\W]+)\s*}}/g.test(eid)) {
+				pathSplit += `[eid="${eid}"]`;
+				node = "";
+			} else if (node.parentNode && node.parentNode.children.length > 1) {
+				let children = [];
+				for (let child of node.parentNode.children) {
+					if (child.tagName == node.tagName) children.push(child);
+				}
+				let index = Array.prototype.indexOf.call(children, node);
+
+				pathSplit += `:nth-of-type(${index + 1})`;
+			}
+
+			node = node.parentNode;
+			if (
+				node == null ||
+				node.tagName == "HTML" ||
+				node.tagName == "BODY" ||
+				node.tagName == "DOM-PARSER" ||
+				node.nodeName == "#document" ||
+				node.hasAttribute("contenteditable")
+			)
+				node = "";
+		}
+
+		pathSplits.unshift(pathSplit);
+	} while (node);
+	let path = pathSplits.join(" > ");
+	if (path && path.includes("<")) {
+		let index = path.lastIndexOf(" >");
+		if (index != -1) path = path.slice(0, index);
+		else {
+			index = path.lastIndexOf("<");
+			path = path.slice(0, index);
+		}
+	}
+
+	return path;
+}