@halleyassist/rule-templater 0.0.11 → 0.0.12

package/README.md

@@ -144,6 +144,29 @@ 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
+```
+
 ## API
 
 ### `RuleTemplate.parse(ruleTemplate)`
@@ -213,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.
@@ -255,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

@@ -4068,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.

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,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.11",
+  "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

@@ -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/RuleTemplater.production.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;