@halleyassist/rule-templater 0.0.1

package/README.md

@@ -0,0 +1,231 @@
+# rule-templater
+
+Parsing and preparation of rule templates for HalleyAssist rules.
+
+## Installation
+
+```bash
+npm install @halleyassist/rule-templater
+```
+
+## Usage
+
+The `rule-templater` package provides utilities for working with rule templates that contain variable placeholders.
+
+### Basic Example
+
+```javascript
+const RuleTemplate = require('@halleyassist/rule-templater');
+
+// Define a template with variables
+const template = 'EventIs(${EVENT_TYPE}) && Value() > ${THRESHOLD}';
+
+// Parse the template to get a RuleTemplate instance
+const parsed = RuleTemplate.parse(template);
+
+// Extract variables from the template (uses AST)
+const variables = parsed.extractVariables();
+console.log(variables);
+// [
+//   { name: 'EVENT_TYPE', filters: [] },
+//   { name: 'THRESHOLD', filters: [] }
+// ]
+
+// Validate that variables are provided correctly
+const validation = parsed.validate({
+    EVENT_TYPE: { value: 'sensor-update', type: 'string' },
+    THRESHOLD: { value: 42, type: 'number' }
+});
+console.log(validation.valid); // true
+
+// Prepare the template with actual values
+const prepared = parsed.prepare({
+    EVENT_TYPE: { value: 'sensor-update', type: 'string' },
+    THRESHOLD: { value: 42, type: 'number' }
+});
+console.log(prepared);
+// 'EventIs("sensor-update") && Value() > 42'
+```
+
+### Complex Example
+
+```javascript
+const template = '!(EventIs(StrConcat("DeviceEvent:measurement:", ${ACTION})) && TimeLastTrueSet("last_measurement") || TimeLastTrueCheck("last_measurement") < ${TIME})';
+
+const parsed = RuleTemplate.parse(template);
+
+// Extract variables
+const variables = parsed.extractVariables();
+// [
+//   { name: 'ACTION', filters: [] },
+//   { name: 'TIME', filters: [] }
+// ]
+
+// Prepare with values
+const prepared = parsed.prepare({
+    ACTION: { value: 'temperature', type: 'string' },
+    TIME: { value: 60, type: 'number' }
+});
+
+// Result: !(EventIs(StrConcat("DeviceEvent:measurement:", "temperature")) && TimeLastTrueSet("last_measurement") || TimeLastTrueCheck("last_measurement") < 60)
+```
+
+### Template Filters
+
+Variables can have filters applied to transform their values. Filters are applied using the pipe (`|`) syntax:
+
+```javascript
+const template = 'EventIs(${EVENT_TYPE|upper})';
+
+const parsed = RuleTemplate.parse(template);
+const variables = parsed.extractVariables();
+// [{ name: 'EVENT_TYPE', filters: ['upper'] }]
+
+// Prepare with filters applied
+const prepared = parsed.prepare({
+    EVENT_TYPE: { value: 'sensor-update' }
+});
+// Result: EventIs(SENSOR-UPDATE)
+```
+
+#### Multiple Filters
+
+Filters can be chained together and are applied in sequence:
+
+```javascript
+const template = 'EventIs(${EVENT|trim|upper|string})';
+
+const parsed = RuleTemplate.parse(template);
+const prepared = parsed.prepare({
+    EVENT: { value: '  test  ' }
+});
+// Result: EventIs("TEST")
+```
+
+#### Available Filters
+
+- **string**: Convert to JSON string representation (adds quotes and escapes)
+- **upper**: Convert to uppercase
+- **lower**: Convert to lowercase
+- **capitalize**: Capitalize first letter
+- **title**: Convert to title case (capitalize each word)
+- **trim**: Remove leading/trailing whitespace
+- **number**: Convert to number
+- **boolean**: Convert to boolean
+- **abs**: Absolute value (for numbers)
+- **round**: Round number to nearest integer
+- **floor**: Round number down
+- **ceil**: Round number up
+
+#### Filter Examples
+
+```javascript
+// String transformation
+'${name|upper}' with name='john' → JOHN
+'${name|capitalize}' with name='john doe' → John doe
+'${name|title}' with name='john doe' → John Doe
+
+// Number operations
+'${value|abs}' with value=-42 → 42
+'${value|round}' with value=3.7 → 4
+'${value|floor}' with value=3.9 → 3
+
+// Chaining filters
+'${text|trim|upper}' with text='  hello  ' → HELLO
+```
+
+## API
+
+### `RuleTemplate.parse(ruleTemplate)`
+
+Parses a rule template string and returns a RuleTemplate instance.
+
+**Parameters:**
+- `ruleTemplate` (string): The template string containing `${VARIABLE}` placeholders
+
+**Returns:** A `RuleTemplate` instance with:
+- `ruleTemplateText`: The original template string
+- `ast`: The parsed Abstract Syntax Tree
+
+### `ruleTemplate.extractVariables()`
+
+Extracts all variables from the template using the AST.
+
+**Returns:** Array of objects with:
+- `name` (string): The variable name
+- `filters` (array): Array of filter names applied to the variable
+
+### `ruleTemplate.validate(variables)`
+
+Validates that all required variables are provided and have valid types.
+
+**Parameters:**
+- `variables` (object): Object mapping variable names to their values and types
+  - Each variable should be an object with:
+    - `value`: The value to substitute (string, number, or boolean)
+    - `type` (optional): The variable type ('string', 'number', 'boolean', etc.)
+
+**Returns:** Object with:
+- `valid` (boolean): Whether validation passed
+- `errors` (array): Array of error messages (empty if valid)
+
+### `ruleTemplate.prepare(variables)`
+
+Prepares the template by replacing variables with their values and applying any filters.
+
+**Parameters:**
+- `variables` (object): Object mapping variable names to their values and types
+  - Each variable should be an object with:
+    - `value`: The value to substitute (string, number, or boolean)
+    - `type` (optional): The variable type ('string', 'number', 'boolean', etc.)
+
+**Returns:** The prepared rule string with variables replaced and filters applied
+
+### `RuleTemplate.validateVariableNode(astNode, variableType)` (Static)
+
+Helper method to validate that an AST node matches the expected variable type.
+
+**Parameters:**
+- `astNode`: The AST node to validate
+- `variableType` (string): The expected variable type
+
+**Returns:** `true` if the node is valid for the given type, `false` otherwise
+
+### `RuleTemplate.TemplateFilters` (Static)
+
+Access to the filter functions used by the template engine. Can be extended with custom filters.
+
+**Example:**
+```javascript
+const RuleTemplate = require('@halleyassist/rule-templater');
+
+// Add a custom filter
+RuleTemplate.TemplateFilters.reverse = (value) => {
+    return String(value).split('').reverse().join('');
+};
+
+// Use the custom filter
+const template = 'EventIs(${EVENT|reverse})';
+const parsed = RuleTemplate.parse(template);
+const result = parsed.prepare({ EVENT: { value: 'test' } });
+// Result: EventIs(tset)
+```
+
+## Variable Types
+
+The following variable types are supported:
+
+- `string`
+- `number`
+- `boolean`
+- `object`
+- `time period`
+- `time value`
+- `string array`
+- `number array`
+- `boolean array`
+- `object array`
+
+## License
+
+ISC

package/index.d.ts

@@ -0,0 +1,91 @@
+export interface VariableInfo {
+    name: string;
+    filters: string[];
+}
+
+export interface VariableValue {
+    value: string | number | boolean;
+    type?: 'string' | 'number' | 'boolean' | 'object' | 'time period' | 'time value' | 'string array' | 'number array' | 'boolean array' | 'object array';
+}
+
+export interface Variables {
+    [key: string]: VariableValue;
+}
+
+export interface ValidationResult {
+    valid: boolean;
+    errors: string[];
+}
+
+export interface ASTNode {
+    type: string;
+    text?: string;
+    children?: ASTNode[];
+    [key: string]: any;
+}
+
+export type FilterFunction = (value: any) => any;
+
+export interface TemplateFiltersType {
+    string: FilterFunction;
+    upper: FilterFunction;
+    lower: FilterFunction;
+    capitalize: FilterFunction;
+    title: FilterFunction;
+    trim: FilterFunction;
+    number: FilterFunction;
+    boolean: FilterFunction;
+    abs: FilterFunction;
+    round: FilterFunction;
+    floor: FilterFunction;
+    ceil: FilterFunction;
+    default: FilterFunction;
+    [key: string]: FilterFunction;
+}
+
+export default class RuleTemplate {
+    ruleTemplateText: string;
+    ast: ASTNode;
+
+    constructor(ruleTemplateText: string, ast: ASTNode);
+
+    /**
+     * Parse a rule template string and return a RuleTemplate instance
+     * @param ruleTemplate The template string to parse
+     * @returns Instance with AST and template text
+     */
+    static parse(ruleTemplate: string): RuleTemplate;
+
+    /**
+     * Extract variables from the template using the AST
+     * @returns Array of {name, filters} objects
+     */
+    extractVariables(): VariableInfo[];
+
+    /**
+     * Validate variable types against the AST
+     * @param variables Object mapping variable names to {value, type} objects
+     * @returns Object with validation results: {valid, errors}
+     */
+    validate(variables: Variables): ValidationResult;
+
+    /**
+     * Prepare the template by replacing variables with their values
+     * Applies any filters specified in the template (e.g., ${var|upper|trim})
+     * @param variables Object mapping variable names to {value, type} objects
+     * @returns The prepared rule string
+     */
+    prepare(variables: Variables): string;
+
+    /**
+     * Helper method to validate if an AST node matches a variable type
+     * @param astNode The AST node to validate
+     * @param variableType The expected variable type
+     * @returns True if valid, false otherwise
+     */
+    static validateVariableNode(astNode: ASTNode | null | undefined, variableType: string): boolean;
+}
+
+export const ParserRules: any[];
+export const VariableTypes: string[];
+export const TemplateFilters: TemplateFiltersType;

package/index.js

@@ -0,0 +1 @@
+module.exports = require('./src/RuleTemplater')

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@halleyassist/rule-templater",
+  "version": "0.0.1",
+  "description": "The grammar for HalleyAssist rules",
+  "main": "index.js",
+  "browser": "./dist/rule-templater.browser.js",
+  "types": "index.d.ts",
+  "scripts": {
+    "test": "mocha",
+    "build": "gulp build"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/HalleyAssist/rule-templater.git"
+  },
+  "author": "",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/HalleyAssist/rule-templater/issues"
+  },
+  "homepage": "https://github.com/HalleyAssist/rule-templater#readme",
+  "dependencies": {
+    "@halleyassist/rule-parser": "^1.0.19",
+    "ebnf": "git+https://github.com/HalleyAssist/node-ebnf.git"
+  },
+  "devDependencies": {
+    "@types/node": "^25.1.0",
+    "browserify": "^17.0.1",
+    "chai": "^4",
+    "gulp": "^5.0.1",
+    "mocha": "^10.8.2",
+    "typescript": "^5.9.3",
+    "unassertify": "^3.0.1",
+    "vinyl-buffer": "^1.0.1",
+    "vinyl-source-stream": "^2.0.0"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "files": [
+    "src/*",
+    "index.js",
+    "index.d.ts",
+    "dist/*"
+  ]
+}

package/src/RuleTemplate.ebnf.js

@@ -0,0 +1,27 @@
+const {Grammars} = require('ebnf');
+
+const grammar = `
+    TEMPLATE_BEGIN       ::= "\${"
+    TEMPLATE_END         ::= "}"
+    PIPE                 ::= "|"
+    IDENT                ::= [A-Za-z_][A-Za-z0-9_]*
+    DOT                  ::= "."
+
+    template_value       ::= TEMPLATE_BEGIN WS* template_expr WS* TEMPLATE_END
+
+    template_expr        ::= template_path (WS* template_pipe WS* template_filter_call)*
+
+    template_pipe        ::= PIPE
+
+    template_path        ::= IDENT (WS* DOT WS* IDENT)*
+
+    template_filter_call ::= template_filter_name (WS* BEGIN_ARGUMENT WS* template_filter_args? WS* END_ARGUMENT)?
+
+    template_filter_name ::= IDENT
+
+    template_filter_args ::= template_filter_arg (WS* "," WS* template_filter_arg)*
+
+    template_filter_arg  ::= value | template_value
+`
+
+module.exports = Grammars.W3C.getRules(grammar);

package/src/RuleTemplater.browser.js

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

package/src/RuleTemplater.js

@@ -0,0 +1,340 @@
+// Note: We import the internal RuleParser.ebnf to extend the grammar with template rules.
+// This creates coupling to the internal structure of @halleyassist/rule-parser.
+const RuleParserRules = require('@halleyassist/rule-parser/src/RuleParser.ebnf'),
+      TemplateGrammar = require('./RuleTemplate.ebnf'),
+      TemplateFilters = require('./TemplateFilters'),
+        {Parser} = require('ebnf');
+
+let ParserCache = null;
+
+const VariableTypes = [
+    'string',
+    'number',
+    'boolean',
+    'object',
+    'time period',
+    '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 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].bnf.push(['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 = ParserCache.getAST(ruleTemplate.trim(), 'statement_main');
+        return new RuleTemplate(ruleTemplate, ast);
+    }
+
+    /**
+     * Extract variables from the template using the AST
+     * @returns {Array} Array of {name, filters: []} objects
+     */
+    extractVariables(){
+        const variables = [];
+        const seen = new Set();
+        
+        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 && !seen.has(varInfo.name)) {
+                    seen.add(varInfo.name);
+                    variables.push(varInfo);
+                }
+            }
+            
+            // Traverse children
+            if (node.children) {
+                for (const child of node.children) {
+                    traverse(child);
+                }
+            }
+        };
+        
+        traverse(this.ast);
+        return variables;
+    }
+
+    /**
+     * 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);
+                }
+            }
+        }
+        
+        return { name, filters };
+    }
+
+    /**
+     * 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`);
+        }
+        
+        const 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;
+        
+        // Validate type if provided
+        if (type && !VariableTypes.includes(type)) {
+            throw new Error(`Invalid variable type '${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}'`);
+                }
+                value = TemplateFilters[filterName](value);
+            }
+            // After applying filters, the result is already a string representation
+            return String(value);
+        }
+        
+        // Convert value to string representation based on type
+        if (type === 'string') {
+            return JSON.stringify(String(value));
+        } else if (type === 'number') {
+            return String(value);
+        } else if (type === 'boolean') {
+            return value ? 'TRUE' : 'FALSE';
+        } else {
+            // Default behavior - just insert the value as-is
+            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);
+    }
+}
+
+// Export the class and parser rules
+module.exports = RuleTemplate;
+module.exports.ParserRules = ParserRules;
+module.exports.VariableTypes = VariableTypes;
+module.exports.TemplateFilters = TemplateFilters;

package/src/TemplateFilters.js

@@ -0,0 +1,63 @@
+/*
+Template filters are functions that transform variable values.
+They are applied in the template syntax as ${variable|filter} or ${variable|filter1|filter2}
+*/
+const TemplateFilters = {
+    // Convert value to JSON string representation
+    string: value => JSON.stringify(String(value)),
+    
+    // Convert to uppercase
+    upper: value => String(value).toUpperCase(),
+    
+    // Convert to lowercase
+    lower: value => String(value).toLowerCase(),
+    
+    // Capitalize first letter
+    capitalize: value => {
+        const str = String(value);
+        return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
+    },
+    
+    // Convert to title case
+    title: value => {
+        return String(value).split(' ')
+            .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+            .join(' ');
+    },
+    
+    // Trim whitespace
+    trim: value => String(value).trim(),
+    
+    // Convert to number
+    number: value => Number(value),
+    
+    // Convert to boolean
+    boolean: value => {
+        if (typeof value === 'boolean') return value;
+        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;
+        }
+        return Boolean(value);
+    },
+    
+    // Convert to absolute value (for numbers)
+    abs: value => Math.abs(Number(value)),
+    
+    // Round number
+    round: value => Math.round(Number(value)),
+    
+    // Floor number
+    floor: value => Math.floor(Number(value)),
+    
+    // Ceil number
+    ceil: value => Math.ceil(Number(value)),
+    
+    // Default value if empty/null/undefined
+    default: (value, defaultValue = '') => {
+        return (value === null || value === undefined || value === '') ? defaultValue : value;
+    }
+}
+
+module.exports = TemplateFilters;