@halleyassist/rule-templater 0.0.16 → 0.0.18

package/src/TemplateFilters.js

@@ -2,6 +2,31 @@
 Template filters are functions that transform variable values.
 They are applied in the template syntax as ${variable|filter} or ${variable|filter1|filter2}
 */
+const HUMANISE_TIME_UNITS = [
+    { name: 'year', seconds: 31536000, aliases: ['year', 'years', 'yr', 'yrs', 'y'] },
+    { name: 'month', seconds: 2592000, aliases: ['month', 'months', 'mo', 'mos'] },
+    { name: 'week', seconds: 604800, aliases: ['week', 'weeks', 'wk', 'wks', 'w'] },
+    { name: 'day', seconds: 86400, aliases: ['day', 'days', 'd'] },
+    { name: 'hour', seconds: 3600, aliases: ['hour', 'hours', 'hr', 'hrs', 'h'] },
+    { name: 'minute', seconds: 60, aliases: ['minute', 'minutes', 'min', 'mins'] },
+    { name: 'second', seconds: 1, aliases: ['second', 'seconds', 'sec', 'secs', 's'] }
+];
+
+const getHumaniseTimeUnit = minUnit => {
+    if (minUnit === null || minUnit === undefined || minUnit === '') {
+        return null;
+    }
+
+    const normalizedMinUnit = String(minUnit).trim().toLowerCase();
+    const unit = HUMANISE_TIME_UNITS.find(candidate => candidate.aliases.includes(normalizedMinUnit));
+
+    if (!unit) {
+        throw new Error(`Unknown humanise_time min_unit \"${minUnit}\"`);
+    }
+
+    return unit;
+};
+
 const TemplateFilters = {
     // Convert value to JSON string representation
     string: varData => {
@@ -125,6 +150,69 @@ const TemplateFilters = {
 
     },
 
+    humanise_list: (varData, joiner = 'and') => {
+        if (typeof varData.value === 'string') {
+            varData.type = 'string';
+            return;
+        }
+
+        if (!Array.isArray(varData.value)) {
+            varData.value = String(varData.value);
+            varData.type = 'string';
+            return;
+        }
+
+        const items = varData.value.map(item => String(item));
+
+        if (items.length === 0) {
+            varData.value = '';
+        } else if (items.length === 1) {
+            [varData.value] = items;
+        } else if (items.length === 2) {
+            varData.value = `${items[0]} ${joiner} ${items[1]}`;
+        } else {
+            varData.value = `${items.slice(0, -1).join(', ')} ${joiner} ${items[items.length - 1]}`;
+        }
+
+        varData.type = 'string';
+
+    },
+
+    humanise_time: (varData, minUnit = null) => {
+        const rawSeconds = Number(varData.value);
+
+        if (isNaN(rawSeconds)) {
+            throw new Error(`Value "${varData.value}" cannot be converted to seconds`);
+        }
+
+        const isNegative = rawSeconds < 0;
+        const absoluteSeconds = Math.abs(rawSeconds);
+        const minimumUnit = getHumaniseTimeUnit(minUnit);
+        const minimumUnitIndex = minimumUnit
+            ? HUMANISE_TIME_UNITS.findIndex(unit => unit.name === minimumUnit.name)
+            : HUMANISE_TIME_UNITS.length - 1;
+        const candidateUnits = HUMANISE_TIME_UNITS.slice(0, minimumUnitIndex + 1);
+        let selectedUnit = candidateUnits.find(unit => absoluteSeconds % unit.seconds === 0);
+        let quantity;
+
+        if (selectedUnit) {
+            quantity = absoluteSeconds / selectedUnit.seconds;
+        } else if (minimumUnit) {
+            selectedUnit = minimumUnit;
+            quantity = Math.floor(absoluteSeconds / selectedUnit.seconds);
+        } else {
+            selectedUnit = HUMANISE_TIME_UNITS[HUMANISE_TIME_UNITS.length - 1];
+            quantity = absoluteSeconds;
+        }
+
+        const signedQuantity = isNegative ? -quantity : quantity;
+        const label = Math.abs(signedQuantity) === 1 ? selectedUnit.name : `${selectedUnit.name}s`;
+
+        varData.value = `${signedQuantity} ${label}`;
+        varData.type = 'string';
+
+    },
+
     // 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') {

package/src/VariableTemplate.js

@@ -37,7 +37,7 @@ class VariableTemplate {
     extractVariable() {
         return {
             name: this.variable.name,
-            filters: this.variable.filters.slice()
+            filters: this.variable.filters.map(filter => filter.name)
         };
     }
 
@@ -62,12 +62,15 @@ class VariableTemplate {
 
         varData = VariableTemplate._cloneVarData(varData);
 
-        for (const filterName of this.variable.filters) {
-            if (!TemplateFilters[filterName]) {
-                throw new Error(`Unknown filter '${filterName}'`);
+        for (const filter of this.variable.filters) {
+            const filterName = typeof filter === 'string' ? filter : filter?.name;
+            const filterArgs = typeof filter === 'string' ? [] : (Array.isArray(filter?.args) ? filter.args : []);
+
+            if (!filterName || !TemplateFilters[filterName]) {
+                throw new Error(`Unknown filter '${filterName || filter}'`);
             }
 
-            TemplateFilters[filterName](varData);
+            TemplateFilters[filterName](varData, ...filterArgs);
         }
 
         return varData;
@@ -98,7 +101,11 @@ class VariableTemplate {
                 const filterNameNode = child.children?.find(c => c.type === 'template_filter_name');
                 const filterName = filterNameNode?.text?.trim();
                 if (filterName) {
-                    filters.push(filterName);
+                    const argsNode = child.children?.find(c => c.type === 'template_filter_args');
+                    filters.push({
+                        name: filterName,
+                        args: VariableTemplate._extractFilterArgs(argsNode)
+                    });
                 }
             }
         }
@@ -121,6 +128,67 @@ class VariableTemplate {
 
         return cloned;
     }
+
+    static _extractFilterArgs(node) {
+        if (!node || !Array.isArray(node.children)) {
+            return [];
+        }
+
+        return node.children
+            .filter(child => child.type === 'template_filter_arg')
+            .map(child => VariableTemplate._extractFilterArgValue(child));
+    }
+
+    static _extractFilterArgValue(node) {
+        if (!node || !Array.isArray(node.children) || node.children.length === 0) {
+            return VariableTemplate._normalizeFilterArgText(node?.text?.trim() || '');
+        }
+
+        const child = node.children[0];
+        if (!child) {
+            return VariableTemplate._normalizeFilterArgText(node.text?.trim() || '');
+        }
+
+        if (child.type === 'value' && Array.isArray(child.children) && child.children.length > 0) {
+            return VariableTemplate._extractFilterArgValue(child);
+        }
+
+        if (child.type === 'string') {
+            try {
+                return JSON.parse(child.text);
+            } catch (error) {
+                return VariableTemplate._normalizeFilterArgText(child.text);
+            }
+        }
+
+        if (child.type === 'number') {
+            return Number(child.text);
+        }
+
+        if (child.type === 'true') {
+            return true;
+        }
+
+        if (child.type === 'false') {
+            return false;
+        }
+
+        if (child.type === 'null') {
+            return null;
+        }
+
+        return VariableTemplate._normalizeFilterArgText(child.text?.trim() || node.text?.trim() || '');
+    }
+
+    static _normalizeFilterArgText(text) {
+        const normalizedText = String(text).trim();
+
+        if ((normalizedText.startsWith('"') && normalizedText.endsWith('"')) || (normalizedText.startsWith("'") && normalizedText.endsWith("'"))) {
+            return normalizedText.slice(1, -1);
+        }
+
+        return normalizedText;
+    }
 }
 
 module.exports = VariableTemplate;

package/src/VariableValidate.js

@@ -139,12 +139,15 @@ class VariableValidate {
             throw new Error('Variable data filters must be an array');
         }
 
-        for (const filterName of normalizedVarData.filters) {
-            if (!TemplateFilters[filterName]) {
-                throw new Error(`Unknown filter '${filterName}'`);
+        for (const filter of normalizedVarData.filters) {
+            const filterName = typeof filter === 'string' ? filter : filter?.name;
+            const filterArgs = typeof filter === 'string' ? [] : (Array.isArray(filter?.args) ? filter.args : []);
+
+            if (!filterName || !TemplateFilters[filterName]) {
+                throw new Error(`Unknown filter '${filterName || filter}'`);
             }
 
-            TemplateFilters[filterName](normalizedVarData);
+            TemplateFilters[filterName](normalizedVarData, ...filterArgs);
         }
 
         return normalizedVarData;