@halleyassist/rule-templater 0.0.11 → 0.0.13

package/README.md

@@ -144,6 +144,49 @@ const prepared = parsed.prepare({
 '${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
+```
+
+### Variable Template
+
+For a single variable expression, use `VariableTemplate`:
+
+```javascript
+const { VariableTemplate } = require('@halleyassist/rule-templater');
+
+const parsed = VariableTemplate.parse('ALERT_PERIOD|time_start|upper');
+const variable = parsed.extractVariable();
+// { name: 'ALERT_PERIOD', filters: ['time_start', 'upper'] }
+
+const formatted = parsed.format({
+    ALERT_PERIOD: {
+        value: { from: '08:00', to: '12:00' },
+        type: 'time period'
+    }
+});
+// { value: '08:00', type: 'string' }
+```
+
 ## API
 
 ### `RuleTemplate.parse(ruleTemplate)`
@@ -213,6 +256,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.
@@ -255,6 +314,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

@@ -1,4 +1,4 @@
-(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.RuleTemplater = f()}})(function(){var define,module,exports;return (function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){
+(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.RuleTemplate = f()}})(function(){var define,module,exports;return (function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){
 module.exports=[{"name":"statement_main","bnf":[["statement","EOF"]]},{"name":"logical_operator","bnf":[["AND"],["OR"]]},{"name":"%statement[2]","bnf":[["logical_operator","expression"]],"fragment":true},{"name":"statement","bnf":[["expression","%statement[2]*"]]},{"name":"expression","bnf":[["not_expression"],["standard_expression"],["parenthesis_expression"]]},{"name":"parenthesis_expression","bnf":[["BEGIN_PARENTHESIS","WS*","statement","WS*","END_PARENTHESIS"]]},{"name":"%not_expression[2]","bnf":[["result"],["parenthesis_expression"]],"fragment":true},{"name":"not_expression","bnf":[["NOT","%not_expression[2]"]]},{"name":"%standard_expression[2][1]","bnf":[["WS*","eq_approx"]],"fragment":true},{"name":"%standard_expression[2][2]","bnf":[["WS*","basic_rhs"]],"fragment":true},{"name":"%standard_expression[2][3][1]","bnf":[["WS+","IS"]],"fragment":true},{"name":"%standard_expression[2][3]","bnf":[["%standard_expression[2][3][1]?","WS+","between"]],"fragment":true},{"name":"%standard_expression[2][4]","bnf":[["WS+","in_expr"]],"fragment":true},{"name":"%standard_expression[2]","bnf":[["%standard_expression[2][1]"],["%standard_expression[2][2]"],["%standard_expression[2][3]"],["%standard_expression[2][4]"]],"fragment":true},{"name":"standard_expression","bnf":[["result","%standard_expression[2]?"]]},{"name":"basic_rhs","bnf":[["operator","WS*","result"]]},{"name":"eq_approx","bnf":[["eq_operator","WS*","\"~\"","WS*","result"]]},{"name":"PLUS","bnf":[["\"+\""]]},{"name":"MINUS","bnf":[["\"-\""]]},{"name":"MULTIPLY","bnf":[["\"*\""]]},{"name":"DIVIDE","bnf":[["\"/\""]]},{"name":"MODULUS","bnf":[["\"%\""]]},{"name":"DEFAULT_VAL","bnf":[["\"??\""]]},{"name":"arithmetic_operator","bnf":[["PLUS"],["MINUS"],["MULTIPLY"],["DIVIDE"],["MODULUS"],["DEFAULT_VAL"]]},{"name":"number_atom","bnf":[["number"]]},{"name":"number_time_atom","bnf":[["number_time"]]},{"name":"tod_atom","bnf":[["number_tod"]]},{"name":"dow_atom","bnf":[["dow"]]},{"name":"arithmetic_operand","bnf":[["fcall"],["number_time_atom"],["number_atom"]]},{"name":"%arithmetic_result[5]","bnf":[["arithmetic_result"],["arithmetic_operand"]],"fragment":true},{"name":"arithmetic_result","bnf":[["arithmetic_operand","WS*","arithmetic_operator","WS*","%arithmetic_result[5]"]]},{"name":"simple_result","bnf":[["fcall"],["value"]]},{"name":"result","bnf":[["arithmetic_result"],["simple_result"]]},{"name":"value_atom","bnf":[["false"],["true"],["array"],["time_period"],["number_time_atom"],["number_atom"],["tod_atom"],["string"]]},{"name":"value","bnf":[["value_atom"]]},{"name":"BEGIN_ARRAY","bnf":[["WS*",/\x5B/,"WS*"]]},{"name":"BEGIN_OBJECT","bnf":[["WS*",/\x7B/,"WS*"]]},{"name":"END_ARRAY","bnf":[["WS*",/\x5D/,"WS*"]]},{"name":"END_OBJECT","bnf":[["WS*",/\x7D/,"WS*"]]},{"name":"NAME_SEPARATOR","bnf":[["WS*",/\x3A/,"WS*"]]},{"name":"VALUE_SEPARATOR","bnf":[["WS*",/\x2C/,"WS*"]]},{"name":"WS","bnf":[[/[\x20\x09\x0A\x0D]/]]},{"name":"operator","bnf":[["GTE"],["LTE"],["GT"],["LT"],["EQ"],["NEQ"]]},{"name":"eq_operator","bnf":[["EQ"],["NEQ"]]},{"name":"BEGIN_ARGUMENT","bnf":[["\"(\""]]},{"name":"END_ARGUMENT","bnf":[["\")\""]]},{"name":"BEGIN_PARENTHESIS","bnf":[["\"(\""]]},{"name":"END_PARENTHESIS","bnf":[["\")\""]]},{"name":"BEGIN_IN","bnf":[[/[Ii]/,/[Nn]/]]},{"name":"in_expr","bnf":[["BEGIN_IN","WS*","BEGIN_PARENTHESIS","WS*","arguments","END_PARENTHESIS"]]},{"name":"argument","bnf":[["statement","WS*"]]},{"name":"%arguments[2]","bnf":[["WS*","\",\"","WS*","argument"]],"fragment":true},{"name":"arguments","bnf":[["argument","%arguments[2]*"]]},{"name":"%fname[1]","bnf":[[/[A-Za-z0-9]/]]},{"name":"fname","bnf":[["%fname[1]+"]]},{"name":"fcall","bnf":[["fname","WS*","BEGIN_ARGUMENT","WS*","arguments?","END_ARGUMENT"]]},{"name":"%between_dash_or_and[1]","bnf":[["WS+",/[Aa]/,/[Nn]/,/[Dd]/,"WS+"]],"fragment":true},{"name":"%between_dash_or_and[2]","bnf":[["WS*",/\-/,"WS*"]],"fragment":true},{"name":"between_dash_or_and","bnf":[["%between_dash_or_and[1]"],["%between_dash_or_and[2]"]]},{"name":"between_number_inner","bnf":[["number_atom"],["number_time_atom"]]},{"name":"between_number","bnf":[["between_number_inner","between_dash_or_and","between_number_inner"]]},{"name":"between_number_time_inner","bnf":[["number_time_atom"]]},{"name":"%between_number_time[4]","bnf":[["WS+","dow_range"]],"fragment":true},{"name":"between_number_time","bnf":[["between_number_time_inner","between_dash_or_and","between_number_time_inner","%between_number_time[4]?"]]},{"name":"between_tod_inner","bnf":[["tod_atom"]]},{"name":"%between_tod[2]","bnf":[["WS+",/[Aa]/,/[Nn]/,/[Dd]/,"WS+"]],"fragment":true},{"name":"%between_tod[4]","bnf":[["WS+","dow_range"]],"fragment":true},{"name":"between_tod","bnf":[["between_tod_inner","%between_tod[2]","between_tod_inner","%between_tod[4]?"]]},{"name":"%between[3]","bnf":[["between_number"],["between_tod"]],"fragment":true},{"name":"between","bnf":[[/[Bb]/,/[Ee]/,/[Tt]/,/[Ww]/,/[Ee]/,/[Ee]/,/[Nn]/,"WS+","%between[3]"]]},{"name":"dow","bnf":[[/[Mm]/,/[Oo]/,/[Nn]/,/[Dd]/,/[Aa]/,/[Yy]/],[/[Mm]/,/[Oo]/,/[Nn]/],[/[Tt]/,/[Uu]/,/[Ee]/,/[Ss]/,/[Dd]/,/[Aa]/,/[Yy]/],[/[Tt]/,/[Uu]/,/[Ee]/],[/[Ww]/,/[Ee]/,/[Dd]/,/[Nn]/,/[Ee]/,/[Ss]/,/[Dd]/,/[Aa]/,/[Yy]/],[/[Ww]/,/[Ee]/,/[Dd]/],[/[Tt]/,/[Hh]/,/[Uu]/,/[Rr]/,/[Ss]/,/[Dd]/,/[Aa]/,/[Yy]/],[/[Tt]/,/[Hh]/,/[Uu]/],[/[Tt]/,/[Hh]/,/[Uu]/,/[Rr]/],[/[Ff]/,/[Rr]/,/[Ii]/,/[Dd]/,/[Aa]/,/[Yy]/],[/[Ff]/,/[Rr]/,/[Ii]/],[/[Ss]/,/[Aa]/,/[Tt]/,/[Uu]/,/[Rr]/,/[Dd]/,/[Aa]/,/[Yy]/],[/[Ss]/,/[Aa]/,/[Tt]/],[/[Ss]/,/[Uu]/,/[Nn]/,/[Dd]/,/[Aa]/,/[Yy]/],[/[Ss]/,/[Uu]/,/[Nn]/]]},{"name":"dow_range_inner","bnf":[["dow_atom"]]},{"name":"%dow_range[4]","bnf":[["WS+",/[Tt]/,/[Oo]/,"WS+","dow_range_inner"]],"fragment":true},{"name":"dow_range","bnf":[[/[Oo]/,/[Nn]/,"WS+","dow_range_inner","%dow_range[4]?"]]},{"name":"between_time_only","bnf":[[/[Bb]/,/[Ee]/,/[Tt]/,/[Ww]/,/[Ee]/,/[Ee]/,/[Nn]/,"WS+","between_number_time"]]},{"name":"between_tod_only","bnf":[[/[Bb]/,/[Ee]/,/[Tt]/,/[Ww]/,/[Ee]/,/[Ee]/,/[Nn]/,"WS+","between_tod"]]},{"name":"between_time_only_atom","bnf":[["between_time_only"]]},{"name":"between_tod_only_atom","bnf":[["between_tod_only"]]},{"name":"%AND[1]","bnf":[["WS*",/&/,/&/,"WS*"]],"fragment":true},{"name":"%AND[2]","bnf":[["WS+",/[Aa]/,/[Nn]/,/[Dd]/,"WS+"]],"fragment":true},{"name":"AND","bnf":[["%AND[1]"],["%AND[2]"]]},{"name":"%OR[1]","bnf":[["WS*",/\|/,/\|/,"WS*"]],"fragment":true},{"name":"%OR[2]","bnf":[["WS+",/[Oo]/,/[Rr]/,"WS+"]],"fragment":true},{"name":"OR","bnf":[["%OR[1]"],["%OR[2]"]]},{"name":"AGO","bnf":[[/[Aa]/,/[Gg]/,/[Oo]/]]},{"name":"GT","bnf":[["\">\""]]},{"name":"LT","bnf":[["\"<\""]]},{"name":"GTE","bnf":[["\">=\""]]},{"name":"LTE","bnf":[["\"<=\""]]},{"name":"IS","bnf":[[/[Ii]/,/[Ss]/]]},{"name":"EQ","bnf":[["\"==\""],["\"=\""]]},{"name":"NEQ","bnf":[["\"!=\""]]},{"name":"%NOT[1]","bnf":[[/!/,"WS*"]],"fragment":true},{"name":"%NOT[2]","bnf":[[/[Nn]/,/[Oo]/,/[Tt]/,"WS+"]],"fragment":true},{"name":"NOT","bnf":[["%NOT[1]"],["%NOT[2]"]]},{"name":"false","bnf":[[/[Ff]/,/[Aa]/,/[Ll]/,/[Ss]/,/[Ee]/]]},{"name":"null","bnf":[[/[Nn]/,/[Uu]/,/[Ll]/,/[Ll]/]]},{"name":"true","bnf":[[/[Tt]/,/[Rr]/,/[Uu]/,/[Ee]/]]},{"name":"%array[2][2]","bnf":[["VALUE_SEPARATOR","value"]],"fragment":true},{"name":"%array[2]","bnf":[["value","%array[2][2]*"]],"fragment":true},{"name":"array","bnf":[["BEGIN_ARRAY","%array[2]?","END_ARRAY"]]},{"name":"unit","bnf":[[/[Ss]/,/[Ee]/,/[Cc]/,/[Oo]/,/[Nn]/,/[Dd]/,/[Ss]/],[/[Mm]/,/[Ii]/,/[Nn]/,/[Uu]/,/[Tt]/,/[Ee]/,/[Ss]/],[/[Hh]/,/[Oo]/,/[Uu]/,/[Rr]/,/[Ss]/],[/[Ww]/,/[Ee]/,/[Ee]/,/[Kk]/,/[Ss]/],[/[Dd]/,/[Aa]/,/[Yy]/,/[Ss]/],[/[Ss]/,/[Ee]/,/[Cc]/,/[Oo]/,/[Nn]/,/[Dd]/],[/[Mm]/,/[Ii]/,/[Nn]/,/[Uu]/,/[Tt]/,/[Ee]/],[/[Ww]/,/[Ee]/,/[Ee]/,/[Kk]/],[/[Hh]/,/[Oo]/,/[Uu]/,/[Rr]/],[/[Dd]/,/[Aa]/,/[Yy]/],[/[Mm]/,/[Ii]/,/[Nn]/,/[Ss]/],[/[Mm]/,/[Ii]/,/[Nn]/]]},{"name":"%number[2][1]","bnf":[[/[0-9]/]]},{"name":"%number[2]","bnf":[["%number[2][1]+"]],"fragment":true},{"name":"%number[3][2]","bnf":[[/[0-9]/]]},{"name":"%number[3]","bnf":[["\".\"","%number[3][2]+"]],"fragment":true},{"name":"%number[4][2]","bnf":[["\"-\""],["\"+\""]],"fragment":true},{"name":"%number[4][3][2]","bnf":[[/[0-9]/]]},{"name":"%number[4][3]","bnf":[["\"0\""],[/[1-9]/,"%number[4][3][2]*"]],"fragment":true},{"name":"%number[4]","bnf":[["\"e\"","%number[4][2]?","%number[4][3]"]],"fragment":true},{"name":"number","bnf":[["\"-\"?","%number[2]","%number[3]?","%number[4]?"]]},{"name":"number_time","bnf":[["number","WS+","unit"]]},{"name":"%number_tod[1][1]","bnf":[[/[0-9]/]]},{"name":"%number_tod[1]","bnf":[["%number_tod[1][1]+"]],"fragment":true},{"name":"%number_tod[3][1]","bnf":[[/[0-9]/]]},{"name":"%number_tod[3]","bnf":[["%number_tod[3][1]+"]],"fragment":true},{"name":"number_tod","bnf":[["%number_tod[1]","\":\"","%number_tod[3]"]]},{"name":"%time_period_ago[2]","bnf":[["WS+","number_time_atom"]],"fragment":true},{"name":"time_period_ago","bnf":[["number_time_atom","%time_period_ago[2]*","WS+","AGO"]]},{"name":"%time_period_ago_between[2]","bnf":[["WS+","number_time_atom"]],"fragment":true},{"name":"%time_period_ago_between[6]","bnf":[["between_time_only_atom"],["between_tod_only_atom"]],"fragment":true},{"name":"time_period_ago_between","bnf":[["number_time_atom","%time_period_ago_between[2]*","WS+","AGO","WS+","%time_period_ago_between[6]"]]},{"name":"time_period_const","bnf":[[/[Tt]/,/[Oo]/,/[Dd]/,/[Aa]/,/[Yy]/],["time_period_ago"]]},{"name":"time_period","bnf":[["time_period_ago_between"],["time_period_const"],["between_tod_only"],["between_time_only"]]},{"name":"%string[2][1]","bnf":[[/[\x20-\x21]/],[/[\x23-\x5B]/],[/[\x5D-\uFFFF]/]],"fragment":true},{"name":"%string[2][2]","bnf":[[/\x22/],[/\x5C/],[/\x2F/],[/\x62/],[/\x66/],[/\x6E/],[/\x72/],[/\x74/],[/\x75/,"HEXDIG","HEXDIG","HEXDIG","HEXDIG"]],"fragment":true},{"name":"%string[2]","bnf":[["%string[2][1]"],[/\x5C/,"%string[2][2]"]],"fragment":true},{"name":"string","bnf":[["'\"'","%string[2]*","'\"'"]]},{"name":"HEXDIG","bnf":[[/[a-fA-F0-9]/]]}]
 },{}],2:[function(require,module,exports){
 const {Parser} = require('ebnf/dist/Parser.js'), {ParsingError} = require('ebnf'), RuleParseError = require('./errors/RuleParseError');
@@ -3644,10 +3644,10 @@ Object.defineProperty(exports, "ParsingError", { enumerable: true, get: function
 exports.Grammars = require("./Grammars");
 
 },{"./Grammars":8,"./Parser":9,"./ParsingError":10,"./TokenError":12}],14:[function(require,module,exports){
+module.exports = require('./RuleTemplate.production.js');
+},{"./RuleTemplate.production.js":16}],15:[function(require,module,exports){
 module.exports=[{"name":"TEMPLATE_BEGIN","bnf":[["\"${\""]]},{"name":"TEMPLATE_END","bnf":[["\"}\""]]},{"name":"PIPE","bnf":[["\"|\""]]},{"name":"%IDENT[2]","bnf":[[/[A-Za-z0-9_]/]]},{"name":"IDENT","bnf":[[/[A-Za-z_]/,"%IDENT[2]*"]]},{"name":"DOT","bnf":[["\".\""]]},{"name":"template_value","bnf":[["TEMPLATE_BEGIN","WS*","template_expr","WS*","TEMPLATE_END"]]},{"name":"%template_expr[2]","bnf":[["WS*","template_pipe","WS*","template_filter_call"]],"fragment":true},{"name":"template_expr","bnf":[["template_path","%template_expr[2]*"]]},{"name":"template_pipe","bnf":[["PIPE"]]},{"name":"%template_path[2]","bnf":[["WS*","DOT","WS*","IDENT"]],"fragment":true},{"name":"template_path","bnf":[["IDENT","%template_path[2]*"]]},{"name":"%template_filter_call[2]","bnf":[["WS*","BEGIN_ARGUMENT","WS*","template_filter_args?","WS*","END_ARGUMENT"]],"fragment":true},{"name":"template_filter_call","bnf":[["template_filter_name","%template_filter_call[2]?"]]},{"name":"template_filter_name","bnf":[["IDENT"]]},{"name":"%template_filter_args[2]","bnf":[["WS*","\",\"","WS*","template_filter_arg"]],"fragment":true},{"name":"template_filter_args","bnf":[["template_filter_arg","%template_filter_args[2]*"]]},{"name":"template_filter_arg","bnf":[["value"],["template_value"]]},{"name":"number_atom","bnf":[["number"],["template_value"]]},{"name":"number_time_atom","bnf":[["number_time"],["template_value","WS+","unit"],["template_value"]]},{"name":"tod_atom","bnf":[["number_tod"],["template_value"]]},{"name":"dow_atom","bnf":[["dow"],["template_value"]]},{"name":"between_time_only_atom","bnf":[["between_time_only"],["template_value"]]},{"name":"between_tod_only_atom","bnf":[["between_tod_only"],["template_value"]]}]
-},{}],15:[function(require,module,exports){
-module.exports = require('./RuleTemplater.production.js');
-},{"./RuleTemplater.production.js":16}],16:[function(require,module,exports){
+},{}],16:[function(require,module,exports){
 // Note: We are coupled closely with the ebnf grammar structure of rule-parser
 const TemplateGrammar = require('./RuleTemplate.production.ebnf.js'),
       TemplateFilters = require('./TemplateFilters'),
@@ -4068,12 +4068,13 @@ 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){
+
+},{"./RuleTemplate.production.ebnf.js":15,"./TemplateFilters":17,"@halleyassist/rule-parser":2,"ebnf":13}],17:[function(require,module,exports){
 /*
 Template filters are functions that transform variable values.
 They are applied in the template syntax as ${variable|filter} or ${variable|filter1|filter2}
@@ -4231,5 +4232,5 @@ const TemplateFilters = {
 }
 
 module.exports = TemplateFilters;
-},{}]},{},[15])(15)
+},{}]},{},[14])(14)
 });

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 {
@@ -50,7 +54,7 @@ export interface TemplateFiltersType {
     [key: string]: FilterFunction;
 }
 
-export default class RuleTemplate {
+export class RuleTemplate {
     ruleTemplateText: string;
     ast: ASTNode;
 
@@ -99,6 +103,42 @@ 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 class VariableTemplate {
+    templateText: string;
+    ast: ASTNode;
+    variable: {
+        name: string;
+        filters: string[];
+    };
+
+    constructor(templateText: string, ast: ASTNode, variableInfo: { name: string; filters: string[] });
+
+    static parse(templateText: string): VariableTemplate;
+
+    extractVariable(): {
+        name: string;
+        filters: string[];
+    };
+
+    format(variableData: VariableValue | Variables): VariableValue;
+}
+
 export const ParserRules: any[];
 export const VariableTypes: string[];
 export const TemplateFilters: TemplateFiltersType;

package/index.js

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

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@halleyassist/rule-templater",
-  "version": "0.0.11",
+  "version": "0.0.13",
   "description": "The grammar for HalleyAssist rules",
-  "main": "src/RuleTemplater.production.js",
+  "main": "src/RuleTemplate.production.js",
   "browser": "./dist/rule-templater.browser.js",
   "types": "index.d.ts",
   "scripts": {

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/RuleTemplate.browser.js

@@ -0,0 +1 @@
+module.exports = require('./RuleTemplate.production.js');

package/src/{RuleTemplater.js → RuleTemplate.js}

@@ -418,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/RuleTemplate.production.js

@@ -0,0 +1,425 @@
+// Note: We are coupled closely with the ebnf grammar structure of rule-parser
+const TemplateGrammar = require('./RuleTemplate.production.ebnf.js'),
+      TemplateFilters = require('./TemplateFilters'),
+      RuleParser = require('@halleyassist/rule-parser'),
+      RuleParserRules = RuleParser.ParserRules,
+      {Parser} = require('ebnf');
+
+let ParserCache = null;
+
+const VariableTypes = [
+    'string',
+    'number',
+    'boolean',
+    'object',
+    'time period',
+    'time period ago',
+    'time value',
+    'string array',
+    'number array',
+    'boolean array',
+    'object array'
+]
+
+const AllowedTypeMapping = {
+    'string': ['string_atom', 'string_concat'],
+    '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'],
+    'boolean array': ['boolean_array'],
+    'object': ['object_atom'],
+    'object array': ['object_array']
+};
+
+// Merge the base grammar with template-specific grammar rules
+const extendedGrammar = [...RuleParserRules]
+for(const rule of TemplateGrammar){
+    const idx = extendedGrammar.findIndex(r => r.name === rule.name);
+    if(idx !== -1){
+        extendedGrammar[idx] = rule;
+    } else {
+        extendedGrammar.push(rule);
+    }
+}
+
+// Add template_value as an alternative to value_atom so templates can be parsed
+const valueAtomIdx = extendedGrammar.findIndex(r => r.name === 'value_atom');
+if (valueAtomIdx !== -1) {
+    extendedGrammar[valueAtomIdx] = Object.assign({}, extendedGrammar[valueAtomIdx]);
+    extendedGrammar[valueAtomIdx].bnf = extendedGrammar[valueAtomIdx].bnf.concat([['template_value']]);
+}
+
+// Export the parser rules for potential external use
+const ParserRules = extendedGrammar;
+
+class RuleTemplate {
+    constructor(ruleTemplateText, ast) {
+        this.ruleTemplateText = ruleTemplateText;
+        this.ast = ast;
+    }
+
+    /**
+     * Parse a rule template string and return a RuleTemplate instance
+     * @param {string} ruleTemplate - The template string to parse
+     * @returns {RuleTemplate} Instance with AST and template text
+     */
+    static parse(ruleTemplate){
+        if(!ParserCache){
+            ParserCache = new Parser(ParserRules, {debug: false})
+        }
+
+        const ast = RuleParser.toAst(ruleTemplate.trim(), ParserCache);
+        return new RuleTemplate(ruleTemplate, ast);
+    }
+
+    /**
+     * Extract variables from the template using the AST
+     * @returns {Array} Array of {name, filters: [], positions: [{start, end}]} objects
+     */
+    extractVariables(){
+        const variables = [];
+        const variableMap = new Map();
+        
+        const traverse = (node) => {
+            if (!node) return;
+            
+            // Check if this is a template_value node
+            if (node.type === 'template_value') {
+                // Extract the variable information
+                const varInfo = this._extractVariableFromNode(node);
+                if (varInfo) {
+                    // Add position to existing variable or create new entry
+                    if (variableMap.has(varInfo.name)) {
+                        const existing = variableMap.get(varInfo.name);
+                        existing.positions.push({
+                            start: varInfo.start,
+                            end: varInfo.end
+                        });
+                    } else {
+                        variableMap.set(varInfo.name, {
+                            name: varInfo.name,
+                            filters: varInfo.filters,
+                            positions: [{
+                                start: varInfo.start,
+                                end: varInfo.end
+                            }]
+                        });
+                    }
+                }
+            }
+            
+            // Traverse children
+            if (node.children) {
+                for (const child of node.children) {
+                    traverse(child);
+                }
+            }
+        };
+        
+        traverse(this.ast);
+        
+        // Convert map to array
+        for (const variable of variableMap.values()) {
+            variables.push(variable);
+        }
+        
+        return variables;
+    }
+
+    /**
+     * Extract function calls from the template using the AST
+     * @returns {Array} Array of unique function names used in the template
+     */
+    extractFunctions(){
+        const functions = new Set();
+        
+        const traverse = (node) => {
+            if (!node) return;
+            
+            // Check if this is a function call node
+            if (node.type === 'fcall') {
+                // Find the function name in children
+                const fnameNode = node.children?.find(c => c.type === 'fname');
+                if (fnameNode && fnameNode.text) {
+                    functions.add(fnameNode.text.trim());
+                }
+            }
+            
+            // Traverse children
+            if (node.children) {
+                for (const child of node.children) {
+                    traverse(child);
+                }
+            }
+        };
+        
+        traverse(this.ast);
+        
+        // Convert set to sorted array for consistent output
+        return Array.from(functions).sort();
+    }
+
+    /**
+     * Extract variable name and filters from a template_value AST node
+     * @private
+     */
+    _extractVariableFromNode(node) {
+        if (node.type !== 'template_value') return null;
+        
+        // Find the template_expr child
+        const templateExpr = node.children?.find(c => c.type === 'template_expr');
+        if (!templateExpr) return null;
+        
+        // Extract the path (variable name)
+        const templatePath = templateExpr.children?.find(c => c.type === 'template_path');
+        if (!templatePath || !templatePath.text) return null;
+        
+        const name = templatePath.text.trim();
+        
+        // Extract filters
+        const filters = [];
+        for (const child of templateExpr.children || []) {
+            if (child.type === 'template_filter_call') {
+                const filterName = this._extractFilterName(child);
+                if (filterName) {
+                    filters.push(filterName);
+                }
+            }
+        }
+        
+        // Extract position information from the node
+        const start = node.start;
+        const end = node.end;
+        
+        return { name, filters, start, end };
+    }
+
+    /**
+     * Extract filter name from template_filter_call node
+     * @private
+     */
+    _extractFilterName(node) {
+        const filterNameNode = node.children?.find(c => c.type === 'template_filter_name');
+        if (!filterNameNode || !filterNameNode.text) return null;
+        
+        return filterNameNode.text.trim();
+    }
+
+    /**
+     * Validate variable types against the AST
+     * @param {Object} variables - Object mapping variable names to {type} objects
+     * @returns {Object} Object with validation results: {valid: boolean, errors: []}
+     */
+    validate(variables) {
+        if (!variables || typeof variables !== 'object') {
+            return {
+                valid: false,
+                errors: ['Variables must be provided as an object']
+            };
+        }
+
+        const errors = [];
+        const extractedVars = this.extractVariables();
+        
+        for (const varInfo of extractedVars) {
+            const varName = varInfo.name;
+            
+            // Check if variable is provided
+            if (!variables.hasOwnProperty(varName)) {
+                errors.push(`Variable '${varName}' not provided in variables object`);
+                continue;
+            }
+            
+            const varData = variables[varName];
+            if (typeof varData !== 'object') {
+                errors.push(`Variable '${varName}' must be an object`);
+                continue;
+            }
+            
+            const { type } = varData;
+            
+            // Validate type if provided
+            if (type && !VariableTypes.includes(type)) {
+                errors.push(`Invalid variable type '${type}' for variable '${varName}'`);
+            }
+        }
+        
+        return {
+            valid: errors.length === 0,
+            errors
+        };
+    }
+
+    /**
+     * Prepare the template by replacing variables with their values
+     * Rebuilds from AST by iterating through children
+     * @param {Object} variables - Object mapping variable names to {value, type} objects
+     * @returns {string} The prepared rule string
+     */
+    prepare(variables){
+        if (!variables || typeof variables !== 'object') {
+            throw new Error('Variables must be provided as an object');
+        }
+
+        // Rebuild the rule string from AST
+        return this._rebuildFromAST(this.ast, variables);
+    }
+
+    /**
+     * Rebuild rule string from AST node, replacing template_value nodes with variable values
+     * @private
+     * @param {Object} node - AST node
+     * @param {Object} variables - Object mapping variable names to {value, type} objects
+     * @returns {string} Rebuilt string
+     */
+    _rebuildFromAST(node, variables) {
+        if (!node) return '';
+        
+        // If this is a template_value node, replace it with the computed value
+        if (node.type === 'template_value') {
+            return this._computeTemplateReplacement(node, variables);
+        }
+        
+        // If node has no children, it's a leaf - return its text
+        if (!node.children || node.children.length === 0) {
+            return node.text || '';
+        }
+        
+        // Node has children - rebuild by iterating through children and preserving gaps
+        let result = '';
+        const originalText = node.text || '';
+        let lastEnd = node.start || 0;
+        
+        for (const child of node.children) {
+            // Add any text between the last child's end and this child's start (gaps/syntax)
+            if (child.start !== undefined && child.start > lastEnd) {
+                result += originalText.substring(lastEnd - (node.start || 0), child.start - (node.start || 0));
+            }
+            
+            // Add the child's rebuilt text
+            result += this._rebuildFromAST(child, variables);
+            
+            // Update lastEnd to this child's end position
+            if (child.end !== undefined) {
+                lastEnd = child.end;
+            }
+        }
+        
+        // Add any remaining text after the last child
+        if (node.end !== undefined && lastEnd < node.end) {
+            result += originalText.substring(lastEnd - (node.start || 0), node.end - (node.start || 0));
+        }
+        
+        return result;
+    }
+
+    /**
+     * Compute the replacement value for a template_value node
+     * @private
+     * @param {Object} node - template_value AST node
+     * @param {Object} variables - Object mapping variable names to {value, type} objects
+     * @returns {string} Replacement string
+     */
+    _computeTemplateReplacement(node, variables) {
+        const templateInfo = this._extractVariableFromNode(node);
+        if (!templateInfo) {
+            throw new Error(`Failed to extract variable information from template node`);
+        }
+        
+        const varName = templateInfo.name;
+        
+        // Validate variable is provided
+        if (!variables.hasOwnProperty(varName)) {
+            throw new Error(`Variable '${varName}' not provided in variables object`);
+        }
+        
+        let varData = variables[varName];
+        if (typeof varData !== 'object' || !varData.hasOwnProperty('value')) {
+            throw new Error(`Variable '${varName}' must be an object with 'value' property`);
+        }
+
+        varData = Object.assign({}, varData);
+        
+        // Require type property for all variables
+        if (!varData.hasOwnProperty('type')) {
+            throw new Error(`Variable '${varName}' must have a 'type' property`);
+        }
+        
+        // Validate type
+        if (!VariableTypes.includes(varData.type)) {
+            throw new Error(`Invalid variable type '${varData.type}' for variable '${varName}'`);
+        }
+        
+        // Apply filters if present
+        if (templateInfo.filters && templateInfo.filters.length > 0) {
+            for (const filterName of templateInfo.filters) {
+                if (!TemplateFilters[filterName]) {
+                    throw new Error(`Unknown filter '${filterName}'`);
+                }
+               
+                TemplateFilters[filterName](varData);
+            }
+        }
+
+        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') {
+            return `"${String(value).replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
+        }
+
+        if (type === 'number') {
+            return String(value);
+        }
+
+        if (type === 'boolean') {
+            return value ? 'true' : 'false';
+        }
+
+        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);
+    }
+
+    /**
+     * Helper method to validate if an AST node matches a variable type
+     * @param {Object} astNode - The AST node to validate
+     * @param {string} variableType - The expected variable type
+     * @returns {boolean} True if valid, false otherwise
+     */
+    static validateVariableNode(astNode, variableType) {
+        if (!astNode || !astNode.type) {
+            return false;
+        }
+
+        const allowedTypes = AllowedTypeMapping[variableType];
+        if (!allowedTypes) {
+            return false;
+        }
+
+        return allowedTypes.includes(astNode.type);
+    }
+}
+
+RuleTemplate.ParserRules = ParserRules;
+RuleTemplate.VariableTypes = VariableTypes;
+RuleTemplate.TemplateFilters = TemplateFilters;
+
+module.exports = RuleTemplate;

package/src/RuleTemplater.browser.js

@@ -1 +1 @@
-module.exports = require('./RuleTemplater.production.js');
+module.exports = require('./RuleTemplate.production.js');

package/src/RuleTemplater.production.js

@@ -13,7 +13,6 @@ const VariableTypes = [
     'boolean',
     'object',
     'time period',
-    'time period ago',
     'time value',
     'string array',
     'number array',
@@ -26,7 +25,6 @@ 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'],
@@ -49,8 +47,7 @@ for(const rule of TemplateGrammar){
 // Add template_value as an alternative to value_atom so templates can be parsed
 const valueAtomIdx = extendedGrammar.findIndex(r => r.name === 'value_atom');
 if (valueAtomIdx !== -1) {
-    extendedGrammar[valueAtomIdx] = Object.assign({}, extendedGrammar[valueAtomIdx]);
-    extendedGrammar[valueAtomIdx].bnf = extendedGrammar[valueAtomIdx].bnf.concat([['template_value']]);
+    extendedGrammar[valueAtomIdx].bnf.push(['template_value']);
 }
 
 // Export the parser rules for potential external use
@@ -337,12 +334,12 @@ class RuleTemplate {
             throw new Error(`Variable '${varName}' not provided in variables object`);
         }
         
-        let varData = variables[varName];
+        const varData = variables[varName];
         if (typeof varData !== 'object' || !varData.hasOwnProperty('value')) {
             throw new Error(`Variable '${varName}' must be an object with 'value' property`);
         }
-
-        varData = Object.assign({}, varData);
+        
+        let { value, type } = varData;
         
         // Require type property for all variables
         if (!varData.hasOwnProperty('type')) {
@@ -350,8 +347,8 @@ class RuleTemplate {
         }
         
         // Validate type
-        if (!VariableTypes.includes(varData.type)) {
-            throw new Error(`Invalid variable type '${varData.type}' for variable '${varName}'`);
+        if (!VariableTypes.includes(type)) {
+            throw new Error(`Invalid variable type '${type}' for variable '${varName}'`);
         }
         
         // Apply filters if present
@@ -360,42 +357,27 @@ class RuleTemplate {
                 if (!TemplateFilters[filterName]) {
                     throw new Error(`Unknown filter '${filterName}'`);
                 }
-               
-                TemplateFilters[filterName](varData);
+                value = TemplateFilters[filterName](value);
             }
+            // After applying filters, the result is already a string representation
+            return String(value);
         }
-
-        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}'`);
-        }
-
+        
+        // Convert value to string representation based on type
         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, '\\"')}"`;
-        }
-
-        if (type === 'number') {
+        } else if (type === 'number') {
             return String(value);
-        }
-
-        if (type === 'boolean') {
+        } else 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);
     }
 
     /**

package/src/VariableTemplate.js

@@ -0,0 +1,126 @@
+const { Parser } = require('ebnf');
+const RuleTemplate = require('./RuleTemplate');
+const TemplateFilters = require('./TemplateFilters');
+
+let ParserCache = null;
+
+class VariableTemplate {
+    constructor(templateText, ast, variableInfo) {
+        this.templateText = templateText;
+        this.ast = ast;
+        this.variable = variableInfo;
+    }
+
+    static parse(templateText) {
+        if (typeof templateText !== 'string') {
+            throw new Error('Variable template must be a string');
+        }
+
+        const expressionText = VariableTemplate._normalizeExpression(templateText);
+        if (!expressionText) {
+            throw new Error('Variable template cannot be empty');
+        }
+
+        if (!ParserCache) {
+            ParserCache = new Parser(RuleTemplate.ParserRules, { debug: false });
+        }
+
+        const ast = ParserCache.getAST(expressionText, 'template_expr');
+        const variableInfo = VariableTemplate._extractVariableFromAst(ast);
+        if (!variableInfo) {
+            throw new Error('Invalid variable template expression');
+        }
+
+        return new VariableTemplate(templateText, ast, variableInfo);
+    }
+
+    extractVariable() {
+        return {
+            name: this.variable.name,
+            filters: this.variable.filters.slice()
+        };
+    }
+
+    format(variableData) {
+        let varData = variableData;
+
+        if (!varData || typeof varData !== 'object') {
+            throw new Error('Variable data must be provided as an object');
+        }
+
+        if (!Object.prototype.hasOwnProperty.call(varData, 'value')) {
+            if (!Object.prototype.hasOwnProperty.call(varData, this.variable.name)) {
+                throw new Error(`Variable '${this.variable.name}' not provided`);
+            }
+
+            varData = varData[this.variable.name];
+        }
+
+        if (!varData || typeof varData !== 'object' || !Object.prototype.hasOwnProperty.call(varData, 'value')) {
+            throw new Error(`Variable '${this.variable.name}' must be an object with 'value' property`);
+        }
+
+        varData = VariableTemplate._cloneVarData(varData);
+
+        for (const filterName of this.variable.filters) {
+            if (!TemplateFilters[filterName]) {
+                throw new Error(`Unknown filter '${filterName}'`);
+            }
+
+            TemplateFilters[filterName](varData);
+        }
+
+        return varData;
+    }
+
+    static _normalizeExpression(templateText) {
+        const trimmed = templateText.trim();
+        if (trimmed.startsWith('${') && trimmed.endsWith('}')) {
+            return trimmed.slice(2, -1).trim();
+        }
+
+        return trimmed;
+    }
+
+    static _extractVariableFromAst(ast) {
+        if (!ast || ast.type !== 'template_expr') {
+            return null;
+        }
+
+        const templatePath = ast.children?.find(c => c.type === 'template_path');
+        if (!templatePath || !templatePath.text) {
+            return null;
+        }
+
+        const filters = [];
+        for (const child of ast.children || []) {
+            if (child.type === 'template_filter_call') {
+                const filterNameNode = child.children?.find(c => c.type === 'template_filter_name');
+                const filterName = filterNameNode?.text?.trim();
+                if (filterName) {
+                    filters.push(filterName);
+                }
+            }
+        }
+
+        return {
+            name: templatePath.text.trim(),
+            filters
+        };
+    }
+
+    static _cloneVarData(varData) {
+        const cloned = Object.assign({}, varData);
+        if (cloned.value && typeof cloned.value === 'object') {
+            if (Array.isArray(cloned.value)) {
+                cloned.value = cloned.value.slice();
+            } else {
+                cloned.value = Object.assign({}, cloned.value);
+            }
+        }
+
+        return cloned;
+    }
+}
+
+module.exports = VariableTemplate;