@cocreate/element-prototype 1.30.0 → 1.31.0

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+# [1.31.0](https://github.com/CoCreate-app/CoCreate-element-prototype/compare/v1.30.0...v1.31.0) (2025-11-16)
+
+
+### Features
+
+* enhance date handling in getValue and add custom operators for number formatting and UID generation ([280a469](https://github.com/CoCreate-app/CoCreate-element-prototype/commit/280a469d7c8b007c4cb2ed35ac7f4645327ac25e))
+
 # [1.30.0](https://github.com/CoCreate-app/CoCreate-element-prototype/compare/v1.29.3...v1.30.0) (2025-10-11)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cocreate/element-prototype",
-  "version": "1.30.0",
+  "version": "1.31.0",
   "description": "A simple element-prototype component in vanilla javascript. Easily configured using HTML5 data-attributes and/or JavaScript API.",
   "keywords": [
     "element-prototype",

package/src/getValue.js

@@ -203,6 +203,8 @@ const handleDateTime = (element, value, valueType) => {
 	} else if (value) {
 		// Initialize a new Date from the string or object
 		value = new Date(value);
+	} else {
+		value = new Date();
 	}
 
 	// Check if value is a valid date
@@ -255,6 +257,58 @@ const handleDateTime = (element, value, valueType) => {
 					let locale = element.getAttribute("locale") || "en-US";
 					value = value.toLocaleString(locale);
 					break;
+				case "addDays":
+					// Add days to the current date
+					const addDays = parseInt(element.getAttribute("add-days") || 0, 10);
+					value.setDate(value.getDate() + addDays);
+					value = value.toISOString();
+					break;
+				case "subtractDays":
+					// Subtract days from the current date
+					const subtractDays = parseInt(element.getAttribute("subtract-days") || 0, 10);
+					value.setDate(value.getDate() - subtractDays);
+					value = value.toISOString();
+					break;
+				case "startOfDay":
+					// Get the start of the current day (12:00 midnight)
+					const startOfDay = new Date(value);
+					startOfDay.setHours(0, 0, 0, 0); // Set time to midnight
+					value = startOfDay.toISOString();
+					break;
+				case "startOfWeek":
+					// Get the start of the current week (Sunday by default)
+					const startOfWeekOffset = parseInt(element.getAttribute("week-start-day") || 0, 10); // Default to Sunday (0)
+					const startOfWeek = new Date(value);
+					startOfWeek.setDate(value.getDate() - value.getDay() + startOfWeekOffset);
+					startOfWeek.setHours(0, 0, 0, 0); // Set to midnight
+					value = startOfWeek.toISOString();
+					break;
+				case "endOfWeek":
+					// Get the end of the current week (Saturday by default)
+					const endOfWeekOffset = parseInt(element.getAttribute("week-start-day") || 0, 10); // Default to Sunday (0)
+					const endOfWeek = new Date(value);
+					endOfWeek.setDate(value.getDate() - value.getDay() + 6 + endOfWeekOffset);
+					endOfWeek.setHours(23, 59, 59, 999); // Set to the end of the day
+					value = endOfWeek.toISOString();
+					break;
+				case "startOfMonth":
+					// Get the start of the month
+					value = new Date(value.getFullYear(), value.getMonth(), 1).toISOString();
+					break;
+				case "endOfMonth":
+					// Get the end of the month
+					value = new Date(value.getFullYear(), value.getMonth() + 1, 0).toISOString();
+					break;
+				case "startOfYear":
+					// Get the start of the year
+					value = new Date(value.getFullYear(), 0, 1).toISOString();
+					break;
+				case "endOfYear":
+					// Get the end of the year
+					value = new Date(value.getFullYear(), 11, 31).toISOString();
+					break;
+				
+
 				default:
 					if (typeof value[valueType] === "function") {
 						value = value[valueType]();

package/src/operators.js

@@ -1,4 +1,4 @@
-import { ObjectId, queryElements, getValueFromObject } from "@cocreate/utils";
+import { ObjectId, queryElements, getValueFromObject, uid } from "@cocreate/utils";
 
 // Operators handled directly for simple, synchronous value retrieval
 const customOperators = new Map(
@@ -54,7 +54,28 @@ const customOperators = new Map(
 			} catch (e) {
 				return value;
 			}
-		}
+		},
+		// TODO: Implement number formatting
+		$numberFormat: (element, args) => {
+			let number = parseFloat(args[0]);
+			// Simple, fixed arg mapping:
+			// args[0] = locale (internationalization)
+			// args[1] = options (object)
+			// args[2] = number (if provided). If not provided, fall back to legacy behavior where args[0] might be the number.
+			if (!Array.isArray(args)) args = [args];
+
+			const locale = args[0] || undefined;
+			const options = args[1] || {};
+			const numCandidate = args[2] !== undefined ? args[2] : args[0];
+
+			number = parseFloat(numCandidate);
+
+			if (isNaN(number)) return String(numCandidate ?? "");
+
+			return new Intl.NumberFormat(locale, options).format(number);
+		},
+		$uid: (element, args) => uid(args[0]) || "",
+
 	})
 );
 
@@ -206,19 +227,32 @@ const findInnermostFunctionCall = (expression) => {
  * @returns {{operator: string, args: string, rawContent: string, fullMatch?: string} | {operator: null, args: string, rawContent: string}}
  */
 const findInnermostOperator = (expression) => {
-    
+    	// Helper function to strip leading and trailing parentheses from a string
+	function stripParentheses(str) {
+		let result = str;
+		if (result.startsWith("(")) {
+			result = result.substring(1);
+		}
+		if (result.endsWith(")")) {
+			result = result.substring(0, result.length - 1);
+		}
+		return result;
+	}
+	let args;
+
     // --- 1. PRIORITY: Find Innermost FUNCTION CALL (Operator with Parentheses) ---
     const functionCall = findInnermostFunctionCall(expression);
 
     if (functionCall) {
-        // Return the full function expression details, including the full string section
-        return {
-            operator: functionCall.operator,
-            args: functionCall.args,
-            rawContent: functionCall.args, // The content inside the parentheses (arguments)
-            fullMatch: functionCall.fullMatch // The operator(args) string (the complete section to replace)
-        };
-    }
+		// Return the full function expression details, including the full string section
+		args = stripParentheses(functionCall.args);
+		return {
+			operator: functionCall.operator,
+			args, // Arguments without parentheses
+			rawContent: functionCall.args, // The content inside the parentheses (arguments)
+			fullMatch: functionCall.fullMatch // The operator(args) string (the complete section to replace)
+		};
+	}
     
     // --- 2. FALLBACK: Find BARE OPERATOR (e.g., $value path) ---
     
@@ -229,18 +263,22 @@ const findInnermostOperator = (expression) => {
     const innermostOperator = findBareOperatorInPath(rawContent, knownOperatorKeys);
 
     if (innermostOperator) {
-        const operatorArgs = rawContent.substring(innermostOperator.length).trim();
-        return {
-            operator: innermostOperator,
-            args: operatorArgs,
-            rawContent: rawContent,
-        };
-    }
+		const operatorArgs = rawContent.substring(innermostOperator.length).trim();
+		args = stripParentheses(operatorArgs);
+		return {
+			operator: innermostOperator,
+			args, // Arguments without parentheses
+			rawContent: rawContent,
+		};
+	}
+
 
+	args = stripParentheses(rawContent);
+	
     // Fallback if no known operator is found
     return {
         operator: null,
-        args: rawContent,
+        args,
         rawContent: rawContent
     };
 };
@@ -276,6 +314,7 @@ function processOperators(
 
 	let processedValue = value;
 	let hasPromise = false;
+	let parsedValue = null
 
 	while (processedValue.includes("$")) {
         
@@ -336,9 +375,18 @@ function processOperators(
 				replacement = resolvedValue ?? "";
 			}
 
-			// Manually replace the matched part of the string
+			if (processedValue === textToReplace) {
+				processedValue = replacement;
+				break;
+			}
+				
 			processedValue = processedValue.replace(textToReplace, replacement);
 
+			if (!processedValue.includes("$")) {
+				// If there are still unresolved operators, we need to continue processing
+				break;
+			}
+
 		} else {
 			// If operator is excluded, we need to advance past it to avoid infinite loop
 			break;