@halleyassist/rule-templater 0.0.10 → 0.0.12

package/README.md

@@ -121,6 +121,8 @@ const prepared = parsed.prepare({
 - **round**: Round number to nearest integer
 - **floor**: Round number down
 - **ceil**: Round number up
+- **time_start**: Extract `from` from `time period` / `time period ago` and convert to `time value`
+- **time_end**: Extract `to` from `time period` / `time period ago` and convert to `time value`
 
 #### Filter Examples
 
@@ -137,6 +139,32 @@ const prepared = parsed.prepare({
 
 // Chaining filters
 '${text|trim|upper}' with text='  hello  ' → HELLO
+
+// Time period conversion
+'${window|time_start}' with window={from:'08:00',to:'12:00'} → 08:00
+```
+
+### General String Templating
+
+For non-rule text templates, use `GeneralTemplate`:
+
+```javascript
+const RuleTemplate = require('@halleyassist/rule-templater');
+const { GeneralTemplate } = RuleTemplate;
+
+const template = 'If a door is opened between ${ALERT_PERIOD | time_start} AND ${ALERT_PERIOD | time_end}';
+
+const variables = GeneralTemplate.getVariables(template);
+// [{ name: 'ALERT_PERIOD', filters: ['time_start', 'time_end'], positions: [...] }]
+
+const parsed = GeneralTemplate.parse(template);
+const prepared = parsed.prepare({
+    ALERT_PERIOD: {
+        value: { from: '08:00', to: '12:00' },
+        type: 'time period'
+    }
+});
+// If a door is opened between 08:00 AND 12:00
 ```
 
 ## API
@@ -208,6 +236,22 @@ Prepares the template by replacing variables with their values and applying any
 
 **Returns:** The prepared rule string with variables replaced and filters applied
 
+### `GeneralTemplate.parse(templateText)`
+
+Parses a general string template and returns a `GeneralTemplate` instance.
+
+### `GeneralTemplate.getVariables(templateText)` (Static)
+
+Extracts variables from a general string template without creating an instance manually.
+
+### `generalTemplate.getVariables()`
+
+Extracts variables from a general string template.
+
+### `generalTemplate.prepare(variables)`
+
+Prepares a general string template by replacing `${...}` placeholders with values and applying filters.
+
 ### `RuleTemplate.validateVariableNode(astNode, variableType)` (Static)
 
 Helper method to validate that an AST node matches the expected variable type.
@@ -222,13 +266,16 @@ Helper method to validate that an AST node matches the expected variable type.
 
 Access to the filter functions used by the template engine. Can be extended with custom filters.
 
+Custom filters receive a cloned `varData` object (`{ value, type }`) used for template rendering. They can mutate both fields without mutating the original input variables.
+
 **Example:**
 ```javascript
 const RuleTemplate = require('@halleyassist/rule-templater');
 
 // Add a custom filter
-RuleTemplate.TemplateFilters.reverse = (value) => {
-    return String(value).split('').reverse().join('');
+RuleTemplate.TemplateFilters.reverse = (varData) => {
+    varData.value = String(varData.value).split('').reverse().join('');
+    return varData;
 };
 
 // Use the custom filter
@@ -247,6 +294,7 @@ The following variable types are supported:
 - `boolean`
 - `object`
 - `time period`
+- `time period ago`
 - `time value`
 - `string array`
 - `number array`

package/dist/rule-templater.browser.js

@@ -3663,6 +3663,7 @@ const VariableTypes = [
     'boolean',
     'object',
     'time period',
+    'time period ago',
     'time value',
     'string array',
     'number array',
@@ -3675,6 +3676,7 @@ const AllowedTypeMapping = {
     'number': ['number_atom', 'math_expr'],
     'boolean': ['boolean_atom', 'boolean_expr'],
     'time period': ['time_period_atom'],
+    'time period ago': ['time_period_atom'],
     'time value': ['time_value_atom', 'tod_atom'],
     'string array': ['string_array'],
     'number array': ['number_array'],
@@ -3985,12 +3987,12 @@ class RuleTemplate {
             throw new Error(`Variable '${varName}' not provided in variables object`);
         }
         
-        const varData = variables[varName];
+        let varData = variables[varName];
         if (typeof varData !== 'object' || !varData.hasOwnProperty('value')) {
             throw new Error(`Variable '${varName}' must be an object with 'value' property`);
         }
-        
-        let { value, type } = varData;
+
+        varData = Object.assign({}, varData);
         
         // Require type property for all variables
         if (!varData.hasOwnProperty('type')) {
@@ -3998,8 +4000,8 @@ class RuleTemplate {
         }
         
         // Validate type
-        if (!VariableTypes.includes(type)) {
-            throw new Error(`Invalid variable type '${type}' for variable '${varName}'`);
+        if (!VariableTypes.includes(varData.type)) {
+            throw new Error(`Invalid variable type '${varData.type}' for variable '${varName}'`);
         }
         
         // Apply filters if present
@@ -4008,27 +4010,42 @@ class RuleTemplate {
                 if (!TemplateFilters[filterName]) {
                     throw new Error(`Unknown filter '${filterName}'`);
                 }
-                value = TemplateFilters[filterName](value);
+               
+                TemplateFilters[filterName](varData);
             }
-            // After applying filters, the result is already a string representation
-            return String(value);
         }
-        
-        // Convert value to string representation based on type
+
+        return this._serializeVarData(varData, varName);
+    }
+
+    _serializeVarData(varData, varName) {
+        const { value, type } = varData;
+
+        if (!VariableTypes.includes(type)) {
+            throw new Error(`Invalid variable type '${type}' for variable '${varName}'`);
+        }
+
         if (type === 'string') {
-            // Escape backslashes first, then quotes in string values.
-            // Order is critical: escaping backslashes first prevents double-escaping.
-            // E.g., "test\" becomes "test\\" then "test\\\"" (correct)
-            // If reversed, "test\" would become "test\\"" then "test\\\\"" (incorrect)
             return `"${String(value).replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
-        } else if (type === 'number') {
+        }
+
+        if (type === 'number') {
             return String(value);
-        } else if (type === 'boolean') {
+        }
+
+        if (type === 'boolean') {
             return value ? 'true' : 'false';
-        } else {
-            // Default behavior - just insert the value as-is
-            return String(value);
         }
+
+        if (type === 'time period' || type === 'time period ago') {
+            let ret = `${value.from} TO ${value.to}`;
+            if(value.ago) {
+                ret += ` AGO ${value.ago[0]} ${value.ago[1]}`;
+            }
+            return ret;
+        }
+
+        return String(value);
     }
 
     /**
@@ -4051,11 +4068,12 @@ class RuleTemplate {
     }
 }
 
-// Export the class and parser rules
+RuleTemplate.ParserRules = ParserRules;
+RuleTemplate.VariableTypes = VariableTypes;
+RuleTemplate.TemplateFilters = TemplateFilters;
+
 module.exports = RuleTemplate;
-module.exports.ParserRules = ParserRules;
-module.exports.VariableTypes = VariableTypes;
-module.exports.TemplateFilters = TemplateFilters;
+
 },{"./RuleTemplate.production.ebnf.js":14,"./TemplateFilters":17,"@halleyassist/rule-parser":2,"ebnf":13}],17:[function(require,module,exports){
 /*
 Template filters are functions that transform variable values.
@@ -4063,59 +4081,153 @@ They are applied in the template syntax as ${variable|filter} or ${variable|filt
 */
 const TemplateFilters = {
     // Convert value to JSON string representation
-    string: value => JSON.stringify(String(value)),
-    
+    string: varData => {
+        varData.value = String(varData.value);
+        varData.type = 'string';
+
+    },
+
     // Convert to uppercase
-    upper: value => String(value).toUpperCase(),
-    
+    upper: varData => {
+        varData.value = String(varData.value).toUpperCase();
+        varData.type = 'string';
+
+    },
+
     // Convert to lowercase
-    lower: value => String(value).toLowerCase(),
-    
+    lower: varData => {
+        varData.value = String(varData.value).toLowerCase();
+        varData.type = 'string';
+
+    },
+
     // Capitalize first letter
-    capitalize: value => {
-        const str = String(value);
-        return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
+    capitalize: varData => {
+        const str = String(varData.value);
+        varData.value = str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
+        varData.type = 'string';
+
     },
-    
+
     // Convert to title case
-    title: value => {
-        return String(value).split(' ')
+    title: varData => {
+        varData.value = String(varData.value).split(' ')
             .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
             .join(' ');
+        varData.type = 'string';
+
     },
-    
+
     // Trim whitespace
-    trim: value => String(value).trim(),
-    
+    trim: varData => {
+        varData.value = String(varData.value).trim();
+        varData.type = 'string';
+
+    },
+
     // Convert to number
-    number: value => Number(value),
-    
+    number: varData => {
+        varData.value = Number(varData.value);
+        varData.type = 'number';
+
+    },
+
     // Convert to boolean
-    boolean: value => {
-        if (typeof value === 'boolean') return value;
+    boolean: varData => {
+        const value = varData.value;
+        if (typeof value === 'boolean') {
+            varData.type = 'boolean';
+
+        }
+
         if (typeof value === 'string') {
             const lower = value.toLowerCase();
-            if (lower === 'true' || lower === '1' || lower === 'yes') return true;
-            if (lower === 'false' || lower === '0' || lower === 'no') return false;
+            if (lower === 'true' || lower === '1' || lower === 'yes') {
+                varData.value = true;
+                varData.type = 'boolean';
+
+            }
+            if (lower === 'false' || lower === '0' || lower === 'no') {
+                varData.value = false;
+                varData.type = 'boolean';
+
+            }
         }
-        return Boolean(value);
+
+        varData.value = Boolean(value);
+        varData.type = 'boolean';
+
     },
-    
+
     // Convert to absolute value (for numbers)
-    abs: value => Math.abs(Number(value)),
-    
+    abs: varData => {
+        varData.value = Math.abs(Number(varData.value));
+        varData.type = 'number';
+
+    },
+
     // Round number
-    round: value => Math.round(Number(value)),
-    
+    round: varData => {
+        varData.value = Math.round(Number(varData.value));
+        varData.type = 'number';
+
+    },
+
     // Floor number
-    floor: value => Math.floor(Number(value)),
-    
+    floor: varData => {
+        varData.value = Math.floor(Number(varData.value));
+        varData.type = 'number';
+
+    },
+
     // Ceil number
-    ceil: value => Math.ceil(Number(value)),
-    
+    ceil: varData => {
+        varData.value = Math.ceil(Number(varData.value));
+        varData.type = 'number';
+
+    },
+
     // Default value if empty/null/undefined
-    default: (value, defaultValue = '') => {
-        return (value === null || value === undefined || value === '') ? defaultValue : value;
+    default: (varData, defaultValue = '') => {
+        varData.value = (varData.value === null || varData.value === undefined || varData.value === '') ? defaultValue : varData.value;
+        if (typeof varData.value === 'string') {
+            varData.type = 'string';
+        } else if (typeof varData.value === 'number') {
+            varData.type = 'number';
+        } else if (typeof varData.value === 'boolean') {
+            varData.type = 'boolean';
+        }
+
+    },
+
+    // Extract start time from time period/time period ago as time value
+    time_start: varData => {
+        if (varData.type === 'time period' || varData.type === 'time period ago') {
+            if (!varData.value || typeof varData.value !== 'object' || !Object.prototype.hasOwnProperty.call(varData.value, 'from')) {
+                throw new Error('time_start filter requires value.from for time period types');
+            }
+
+            varData.value = varData.value.from;
+            varData.type = 'time value';
+            return;
+        }
+
+        throw new Error('time_start filter requires variable type to be \"time period\" or \"time period ago\"');
+    },
+
+    // Extract end time from time period/time period ago as time value
+    time_end: varData => {
+        if (varData.type === 'time period' || varData.type === 'time period ago') {
+            if (!varData.value || typeof varData.value !== 'object' || !Object.prototype.hasOwnProperty.call(varData.value, 'to')) {
+                throw new Error('time_end filter requires value.from for time period types');
+            }
+
+            varData.value = varData.value.to;
+            varData.type = 'time value';
+            return;
+        }
+
+        throw new Error('time_end filter requires variable type to be \"time period\" or \"time period ago\"');
     }
 }
 

package/index.d.ts

@@ -10,8 +10,12 @@ export interface VariableInfo {
 }
 
 export interface VariableValue {
-    value: string | number | boolean;
-    type?: 'string' | 'number' | 'boolean' | 'object' | 'time period' | 'time value' | 'string array' | 'number array' | 'boolean array' | 'object array';
+    value: string | number | boolean | {
+        from: string;
+        to: string;
+        ago?: [number, string];
+    };
+    type?: 'string' | 'number' | 'boolean' | 'object' | 'time period' | 'time period ago' | 'time value' | 'string array' | 'number array' | 'boolean array' | 'object array';
 }
 
 export interface Variables {
@@ -30,7 +34,7 @@ export interface ASTNode {
     [key: string]: any;
 }
 
-export type FilterFunction = (value: any) => any;
+export type FilterFunction = (varData: VariableValue, ...args: any[]) => VariableValue | any;
 
 export interface TemplateFiltersType {
     string: FilterFunction;
@@ -46,10 +50,11 @@ export interface TemplateFiltersType {
     floor: FilterFunction;
     ceil: FilterFunction;
     default: FilterFunction;
+    time_start: FilterFunction;
     [key: string]: FilterFunction;
 }
 
-export default class RuleTemplate {
+export class RuleTemplate {
     ruleTemplateText: string;
     ast: ASTNode;
 
@@ -98,6 +103,22 @@ export default class RuleTemplate {
     static validateVariableNode(astNode: ASTNode | null | undefined, variableType: string): boolean;
 }
 
+export class GeneralTemplate {
+    templateText: string;
+
+    constructor(templateText: string);
+
+    static parse(templateText: string): GeneralTemplate;
+
+    static getVariables(templateText: string): VariableInfo[];
+
+    getVariables(): VariableInfo[];
+
+    extractVariables(): VariableInfo[];
+
+    prepare(variables: Variables): string;
+}
+
 export const ParserRules: any[];
 export const VariableTypes: string[];
 export const TemplateFilters: TemplateFiltersType;

package/index.js

@@ -1 +1,8 @@
-module.exports = require('./src/RuleTemplater')
+const RuleTemplate = require('./src/RuleTemplater');
+const GeneralTemplate = require('./src/GeneralTemplate');
+
+module.exports.RuleTemplate = RuleTemplate;
+module.exports.ParserRules = RuleTemplate.ParserRules;
+module.exports.VariableTypes = RuleTemplate.VariableTypes;
+module.exports.TemplateFilters = RuleTemplate.TemplateFilters;
+module.exports.GeneralTemplate = GeneralTemplate;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@halleyassist/rule-templater",
-  "version": "0.0.10",
+  "version": "0.0.12",
   "description": "The grammar for HalleyAssist rules",
   "main": "src/RuleTemplater.production.js",
   "browser": "./dist/rule-templater.browser.js",

package/src/GeneralTemplate.js

@@ -0,0 +1,125 @@
+const TemplateFilters = require('./TemplateFilters');
+
+class GeneralTemplate {
+    constructor(templateText) {
+        this.templateText = templateText;
+    }
+
+    static parse(templateText) {
+        return new GeneralTemplate(templateText);
+    }
+
+    static getVariables(templateText) {
+        return GeneralTemplate.parse(templateText).getVariables();
+    }
+
+    getVariables() {
+        const variables = [];
+        const variableMap = new Map();
+        const pattern = /\$\{([^}]*)\}/g;
+        
+        for (const match of this.templateText.matchAll(pattern)) {
+            const parsedExpression = this._parseTemplateExpression(match[1]);
+            if (parsedExpression) {
+                if (variableMap.has(parsedExpression.name)) {
+                    const existing = variableMap.get(parsedExpression.name);
+                    existing.positions.push({
+                        start: match.index,
+                        end: match.index + match[0].length
+                    });
+                    existing.filters = Array.from(new Set(existing.filters.concat(parsedExpression.filters)));
+                } else {
+                    variableMap.set(parsedExpression.name, {
+                        name: parsedExpression.name,
+                        filters: parsedExpression.filters,
+                        positions: [{
+                            start: match.index,
+                            end: match.index + match[0].length
+                        }]
+                    });
+                }
+            }
+        }
+
+        for (const variable of variableMap.values()) {
+            variables.push(variable);
+        }
+
+        return variables;
+    }
+
+    extractVariables() {
+        return this.getVariables();
+    }
+
+    prepare(variables) {
+        if (!variables || typeof variables !== 'object') {
+            throw new Error('Variables must be provided as an object');
+        }
+
+        return this.templateText.replace(/\$\{([^}]*)\}/g, (matchText, expression) => {
+            const parsedExpression = this._parseTemplateExpression(expression);
+            if (!parsedExpression) {
+                return matchText;
+            }
+
+            const varName = parsedExpression.name;
+            if (!Object.prototype.hasOwnProperty.call(variables, varName)) {
+                throw new Error(`Variable '${varName}' not provided in variables object`);
+            }
+
+            let varData = variables[varName];
+            if (typeof varData !== 'object' || !Object.prototype.hasOwnProperty.call(varData, 'value')) {
+                throw new Error(`Variable '${varName}' must be an object with 'value' property`);
+            }
+
+            varData = Object.assign({}, varData);
+
+            if (parsedExpression.filters && parsedExpression.filters.length > 0) {
+                for (const filterName of parsedExpression.filters) {
+                    if (!TemplateFilters[filterName]) {
+                        throw new Error(`Unknown filter '${filterName}'`);
+                    }
+
+                    TemplateFilters[filterName](varData);
+                }
+            }
+
+            return this._serializeVariable(varData);
+        });
+    }
+
+    _parseTemplateExpression(expression) {
+        if (!expression) {
+            return null;
+        }
+
+        const segments = expression.split('|').map(s => s.trim()).filter(Boolean);
+        if (segments.length === 0) {
+            return null;
+        }
+
+        return {
+            name: segments[0],
+            filters: segments.slice(1)
+        };
+    }
+
+    _serializeVariable(varData) {
+        if (varData.value === null || varData.value === undefined) {
+            return '';
+        }
+
+        if (varData.type === 'time period' || varData.type === 'time period ago') {
+            let ret = `${varData.value.from} TO ${varData.value.to}`;
+            if (varData.value.ago) {
+                ret += ` AGO ${varData.value.ago[0]} ${varData.value.ago[1]}`;
+            }
+            return ret;
+        }
+
+        return String(varData.value);
+    }
+}
+
+module.exports = GeneralTemplate;

package/src/RuleTemplater.js

@@ -13,6 +13,7 @@ const VariableTypes = [
     'boolean',
     'object',
     'time period',
+    'time period ago',
     'time value',
     'string array',
     'number array',
@@ -25,6 +26,7 @@ const AllowedTypeMapping = {
     'number': ['number_atom', 'math_expr'],
     'boolean': ['boolean_atom', 'boolean_expr'],
     'time period': ['time_period_atom'],
+    'time period ago': ['time_period_atom'],
     'time value': ['time_value_atom', 'tod_atom'],
     'string array': ['string_array'],
     'number array': ['number_array'],
@@ -335,12 +337,12 @@ class RuleTemplate {
             throw new Error(`Variable '${varName}' not provided in variables object`);
         }
         
-        const varData = variables[varName];
+        let varData = variables[varName];
         if (typeof varData !== 'object' || !varData.hasOwnProperty('value')) {
             throw new Error(`Variable '${varName}' must be an object with 'value' property`);
         }
-        
-        let { value, type } = varData;
+
+        varData = Object.assign({}, varData);
         
         // Require type property for all variables
         if (!varData.hasOwnProperty('type')) {
@@ -348,8 +350,8 @@ class RuleTemplate {
         }
         
         // Validate type
-        if (!VariableTypes.includes(type)) {
-            throw new Error(`Invalid variable type '${type}' for variable '${varName}'`);
+        if (!VariableTypes.includes(varData.type)) {
+            throw new Error(`Invalid variable type '${varData.type}' for variable '${varName}'`);
         }
         
         // Apply filters if present
@@ -358,27 +360,42 @@ class RuleTemplate {
                 if (!TemplateFilters[filterName]) {
                     throw new Error(`Unknown filter '${filterName}'`);
                 }
-                value = TemplateFilters[filterName](value);
+               
+                TemplateFilters[filterName](varData);
             }
-            // After applying filters, the result is already a string representation
-            return String(value);
         }
-        
-        // Convert value to string representation based on type
+
+        return this._serializeVarData(varData, varName);
+    }
+
+    _serializeVarData(varData, varName) {
+        const { value, type } = varData;
+
+        if (!VariableTypes.includes(type)) {
+            throw new Error(`Invalid variable type '${type}' for variable '${varName}'`);
+        }
+
         if (type === 'string') {
-            // Escape backslashes first, then quotes in string values.
-            // Order is critical: escaping backslashes first prevents double-escaping.
-            // E.g., "test\" becomes "test\\" then "test\\\"" (correct)
-            // If reversed, "test\" would become "test\\"" then "test\\\\"" (incorrect)
             return `"${String(value).replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
-        } else if (type === 'number') {
+        }
+
+        if (type === 'number') {
             return String(value);
-        } else if (type === 'boolean') {
+        }
+
+        if (type === 'boolean') {
             return value ? 'true' : 'false';
-        } else {
-            // Default behavior - just insert the value as-is
-            return String(value);
         }
+
+        if (type === 'time period' || type === 'time period ago') {
+            let ret = `${value.from} TO ${value.to}`;
+            if(value.ago) {
+                ret += ` AGO ${value.ago[0]} ${value.ago[1]}`;
+            }
+            return ret;
+        }
+
+        return String(value);
     }
 
     /**
@@ -401,8 +418,8 @@ class RuleTemplate {
     }
 }
 
-// Export the class and parser rules
+RuleTemplate.ParserRules = ParserRules;
+RuleTemplate.VariableTypes = VariableTypes;
+RuleTemplate.TemplateFilters = TemplateFilters;
+
 module.exports = RuleTemplate;
-module.exports.ParserRules = ParserRules;
-module.exports.VariableTypes = VariableTypes;
-module.exports.TemplateFilters = TemplateFilters;

package/src/RuleTemplater.production.js

@@ -13,6 +13,7 @@ const VariableTypes = [
     'boolean',
     'object',
     'time period',
+    'time period ago',
     'time value',
     'string array',
     'number array',
@@ -25,6 +26,7 @@ const AllowedTypeMapping = {
     'number': ['number_atom', 'math_expr'],
     'boolean': ['boolean_atom', 'boolean_expr'],
     'time period': ['time_period_atom'],
+    'time period ago': ['time_period_atom'],
     'time value': ['time_value_atom', 'tod_atom'],
     'string array': ['string_array'],
     'number array': ['number_array'],
@@ -335,12 +337,12 @@ class RuleTemplate {
             throw new Error(`Variable '${varName}' not provided in variables object`);
         }
         
-        const varData = variables[varName];
+        let varData = variables[varName];
         if (typeof varData !== 'object' || !varData.hasOwnProperty('value')) {
             throw new Error(`Variable '${varName}' must be an object with 'value' property`);
         }
-        
-        let { value, type } = varData;
+
+        varData = Object.assign({}, varData);
         
         // Require type property for all variables
         if (!varData.hasOwnProperty('type')) {
@@ -348,8 +350,8 @@ class RuleTemplate {
         }
         
         // Validate type
-        if (!VariableTypes.includes(type)) {
-            throw new Error(`Invalid variable type '${type}' for variable '${varName}'`);
+        if (!VariableTypes.includes(varData.type)) {
+            throw new Error(`Invalid variable type '${varData.type}' for variable '${varName}'`);
         }
         
         // Apply filters if present
@@ -358,27 +360,42 @@ class RuleTemplate {
                 if (!TemplateFilters[filterName]) {
                     throw new Error(`Unknown filter '${filterName}'`);
                 }
-                value = TemplateFilters[filterName](value);
+               
+                TemplateFilters[filterName](varData);
             }
-            // After applying filters, the result is already a string representation
-            return String(value);
         }
-        
-        // Convert value to string representation based on type
+
+        return this._serializeVarData(varData, varName);
+    }
+
+    _serializeVarData(varData, varName) {
+        const { value, type } = varData;
+
+        if (!VariableTypes.includes(type)) {
+            throw new Error(`Invalid variable type '${type}' for variable '${varName}'`);
+        }
+
         if (type === 'string') {
-            // Escape backslashes first, then quotes in string values.
-            // Order is critical: escaping backslashes first prevents double-escaping.
-            // E.g., "test\" becomes "test\\" then "test\\\"" (correct)
-            // If reversed, "test\" would become "test\\"" then "test\\\\"" (incorrect)
             return `"${String(value).replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
-        } else if (type === 'number') {
+        }
+
+        if (type === 'number') {
             return String(value);
-        } else if (type === 'boolean') {
+        }
+
+        if (type === 'boolean') {
             return value ? 'true' : 'false';
-        } else {
-            // Default behavior - just insert the value as-is
-            return String(value);
         }
+
+        if (type === 'time period' || type === 'time period ago') {
+            let ret = `${value.from} TO ${value.to}`;
+            if(value.ago) {
+                ret += ` AGO ${value.ago[0]} ${value.ago[1]}`;
+            }
+            return ret;
+        }
+
+        return String(value);
     }
 
     /**
@@ -401,8 +418,8 @@ class RuleTemplate {
     }
 }
 
-// Export the class and parser rules
+RuleTemplate.ParserRules = ParserRules;
+RuleTemplate.VariableTypes = VariableTypes;
+RuleTemplate.TemplateFilters = TemplateFilters;
+
 module.exports = RuleTemplate;
-module.exports.ParserRules = ParserRules;
-module.exports.VariableTypes = VariableTypes;
-module.exports.TemplateFilters = TemplateFilters;

package/src/TemplateFilters.js

@@ -4,59 +4,153 @@ They are applied in the template syntax as ${variable|filter} or ${variable|filt
 */
 const TemplateFilters = {
     // Convert value to JSON string representation
-    string: value => JSON.stringify(String(value)),
-    
+    string: varData => {
+        varData.value = String(varData.value);
+        varData.type = 'string';
+
+    },
+
     // Convert to uppercase
-    upper: value => String(value).toUpperCase(),
-    
+    upper: varData => {
+        varData.value = String(varData.value).toUpperCase();
+        varData.type = 'string';
+
+    },
+
     // Convert to lowercase
-    lower: value => String(value).toLowerCase(),
-    
+    lower: varData => {
+        varData.value = String(varData.value).toLowerCase();
+        varData.type = 'string';
+
+    },
+
     // Capitalize first letter
-    capitalize: value => {
-        const str = String(value);
-        return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
+    capitalize: varData => {
+        const str = String(varData.value);
+        varData.value = str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
+        varData.type = 'string';
+
     },
-    
+
     // Convert to title case
-    title: value => {
-        return String(value).split(' ')
+    title: varData => {
+        varData.value = String(varData.value).split(' ')
             .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
             .join(' ');
+        varData.type = 'string';
+
     },
-    
+
     // Trim whitespace
-    trim: value => String(value).trim(),
-    
+    trim: varData => {
+        varData.value = String(varData.value).trim();
+        varData.type = 'string';
+
+    },
+
     // Convert to number
-    number: value => Number(value),
-    
+    number: varData => {
+        varData.value = Number(varData.value);
+        varData.type = 'number';
+
+    },
+
     // Convert to boolean
-    boolean: value => {
-        if (typeof value === 'boolean') return value;
+    boolean: varData => {
+        const value = varData.value;
+        if (typeof value === 'boolean') {
+            varData.type = 'boolean';
+
+        }
+
         if (typeof value === 'string') {
             const lower = value.toLowerCase();
-            if (lower === 'true' || lower === '1' || lower === 'yes') return true;
-            if (lower === 'false' || lower === '0' || lower === 'no') return false;
+            if (lower === 'true' || lower === '1' || lower === 'yes') {
+                varData.value = true;
+                varData.type = 'boolean';
+
+            }
+            if (lower === 'false' || lower === '0' || lower === 'no') {
+                varData.value = false;
+                varData.type = 'boolean';
+
+            }
         }
-        return Boolean(value);
+
+        varData.value = Boolean(value);
+        varData.type = 'boolean';
+
     },
-    
+
     // Convert to absolute value (for numbers)
-    abs: value => Math.abs(Number(value)),
-    
+    abs: varData => {
+        varData.value = Math.abs(Number(varData.value));
+        varData.type = 'number';
+
+    },
+
     // Round number
-    round: value => Math.round(Number(value)),
-    
+    round: varData => {
+        varData.value = Math.round(Number(varData.value));
+        varData.type = 'number';
+
+    },
+
     // Floor number
-    floor: value => Math.floor(Number(value)),
-    
+    floor: varData => {
+        varData.value = Math.floor(Number(varData.value));
+        varData.type = 'number';
+
+    },
+
     // Ceil number
-    ceil: value => Math.ceil(Number(value)),
-    
+    ceil: varData => {
+        varData.value = Math.ceil(Number(varData.value));
+        varData.type = 'number';
+
+    },
+
     // Default value if empty/null/undefined
-    default: (value, defaultValue = '') => {
-        return (value === null || value === undefined || value === '') ? defaultValue : value;
+    default: (varData, defaultValue = '') => {
+        varData.value = (varData.value === null || varData.value === undefined || varData.value === '') ? defaultValue : varData.value;
+        if (typeof varData.value === 'string') {
+            varData.type = 'string';
+        } else if (typeof varData.value === 'number') {
+            varData.type = 'number';
+        } else if (typeof varData.value === 'boolean') {
+            varData.type = 'boolean';
+        }
+
+    },
+
+    // Extract start time from time period/time period ago as time value
+    time_start: varData => {
+        if (varData.type === 'time period' || varData.type === 'time period ago') {
+            if (!varData.value || typeof varData.value !== 'object' || !Object.prototype.hasOwnProperty.call(varData.value, 'from')) {
+                throw new Error('time_start filter requires value.from for time period types');
+            }
+
+            varData.value = varData.value.from;
+            varData.type = 'time value';
+            return;
+        }
+
+        throw new Error('time_start filter requires variable type to be \"time period\" or \"time period ago\"');
+    },
+
+    // Extract end time from time period/time period ago as time value
+    time_end: varData => {
+        if (varData.type === 'time period' || varData.type === 'time period ago') {
+            if (!varData.value || typeof varData.value !== 'object' || !Object.prototype.hasOwnProperty.call(varData.value, 'to')) {
+                throw new Error('time_end filter requires value.from for time period types');
+            }
+
+            varData.value = varData.value.to;
+            varData.type = 'time value';
+            return;
+        }
+
+        throw new Error('time_end filter requires variable type to be \"time period\" or \"time period ago\"');
     }
 }