xlsform2lstsv 0.2.2 → 0.3.0

package/README.md

@@ -35,7 +35,7 @@ Convert XLSForm surveys to LimeSurvey TSV format.
   - its a complex task to ensure the transpiler covers everything and we currently cannot guarantee error free/complete transpiling 
 
 - constraint_message ❌
-- XLSForms Calculation ❌
+- XLSForms Calculation ✅ (`calculate` type → LimeSurvey Equation question `*`; `${var}` references in labels/hints converted to EM `{var}` syntax)
 - XLSForms Trigger ❌
 - Repeats ❌
 - LimeSurvey Assessments ❌

package/dist/converters/xpathTranspiler.js

@@ -38,7 +38,7 @@ function sanitizeName(name) {
  * @returns The transpiled LimeSurvey expression string
  * @throws Error if an unsupported node structure is encountered
  */
-function transpile(node, lookupAnswerCode) {
+function transpile(node, ctx) {
     if (!node)
         return '';
     // https://getodk.github.io/xforms-spec/#xpath-functions
@@ -46,29 +46,30 @@ function transpile(node, lookupAnswerCode) {
     if (node.id) {
         switch (node.id) {
             case 'count':
-                return `count(${node.args?.map(arg => transpile(arg, lookupAnswerCode)).join(', ') || ''})`;
+                return `count(${node.args?.map(arg => transpile(arg, ctx)).join(', ') || ''})`;
             case 'concat':
-                return node.args?.map(arg => transpile(arg, lookupAnswerCode)).join(' + ') || '';
+                return node.args?.map(arg => transpile(arg, ctx)).join(' + ') || '';
             case 'regex':
-                return `regexMatch(${node.args?.map(arg => transpile(arg, lookupAnswerCode)).join(', ') || ''})`;
+                return `regexMatch(${node.args?.map(arg => transpile(arg, ctx)).join(', ') || ''})`;
             case 'contains':
                 // Custom handling for contains
                 if (node.args?.length === 2) {
-                    return `contains(${transpile(node.args[0], lookupAnswerCode)}, ${transpile(node.args[1], lookupAnswerCode)})`;
+                    return `contains(${transpile(node.args[0], ctx)}, ${transpile(node.args[1], ctx)})`;
                 }
                 break;
             case 'selected':
-                // Handle selected(${field}, 'value') -> (field=="value")
+                // Handle selected(${field}, 'value')
                 if (node.args?.length === 2) {
                     const fieldArg = node.args[0];
                     const valueArg = node.args[1];
-                    const fieldName = transpile(fieldArg, lookupAnswerCode);
-                    let value = transpile(valueArg, lookupAnswerCode);
-                    // Remove any existing quotes and use double quotes
+                    const fieldName = transpile(fieldArg, ctx);
+                    let value = transpile(valueArg, ctx);
+                    // Remove any existing quotes
                     value = value.replace(/^['"]|['"]$/g, "");
                     const sanitizedField = sanitizeName(fieldName);
-                    if (lookupAnswerCode) {
-                        value = lookupAnswerCode(sanitizedField, value);
+                    // Use buildSelectedExpr if available (handles select_one vs select_multiple)
+                    if (ctx?.buildSelectedExpr) {
+                        return ctx.buildSelectedExpr(sanitizedField, value);
                     }
                     return `(${sanitizedField}=="${value}")`;
                 }
@@ -76,66 +77,73 @@ function transpile(node, lookupAnswerCode) {
             case 'string':
                 // string() function - just return the argument
                 if (node.args?.length === 1) {
-                    return transpile(node.args[0], lookupAnswerCode);
+                    return transpile(node.args[0], ctx);
                 }
                 break;
             case 'number':
                 // number() function - just return the argument
                 if (node.args?.length === 1) {
-                    return transpile(node.args[0], lookupAnswerCode);
+                    return transpile(node.args[0], ctx);
                 }
                 break;
             case 'floor':
                 if (node.args?.length === 1) {
-                    return `floor(${transpile(node.args[0], lookupAnswerCode)})`;
+                    return `floor(${transpile(node.args[0], ctx)})`;
                 }
                 break;
             case 'ceiling':
                 if (node.args?.length === 1) {
-                    return `ceil(${transpile(node.args[0], lookupAnswerCode)})`;
+                    return `ceil(${transpile(node.args[0], ctx)})`;
                 }
                 break;
             case 'round':
                 if (node.args?.length === 1) {
-                    return `round(${transpile(node.args[0], lookupAnswerCode)})`;
+                    return `round(${transpile(node.args[0], ctx)})`;
                 }
                 break;
             case 'sum':
                 if (node.args?.length === 1) {
-                    return `sum(${transpile(node.args[0], lookupAnswerCode)})`;
+                    return `sum(${transpile(node.args[0], ctx)})`;
                 }
                 break;
             case 'substring':
                 if (node.args && node.args.length >= 2) {
-                    const stringArg = transpile(node.args[0], lookupAnswerCode);
-                    const startArg = transpile(node.args[1], lookupAnswerCode);
-                    const lengthArg = node.args.length > 2 ? transpile(node.args[2], lookupAnswerCode) : '';
+                    const stringArg = transpile(node.args[0], ctx);
+                    const startArg = transpile(node.args[1], ctx);
+                    const lengthArg = node.args.length > 2 ? transpile(node.args[2], ctx) : '';
                     return `substr(${stringArg}, ${startArg}${lengthArg ? ', ' + lengthArg : ''})`;
                 }
                 break;
             case 'string-length':
                 if (node.args?.length === 1) {
-                    return `strlen(${transpile(node.args[0], lookupAnswerCode)})`;
+                    return `strlen(${transpile(node.args[0], ctx)})`;
                 }
                 break;
             case 'starts-with':
                 if (node.args?.length === 2) {
-                    return `startsWith(${transpile(node.args[0], lookupAnswerCode)}, ${transpile(node.args[1], lookupAnswerCode)})`;
+                    return `startsWith(${transpile(node.args[0], ctx)}, ${transpile(node.args[1], ctx)})`;
                 }
                 break;
             case 'ends-with':
                 if (node.args?.length === 2) {
-                    return `endsWith(${transpile(node.args[0], lookupAnswerCode)}, ${transpile(node.args[1], lookupAnswerCode)})`;
+                    return `endsWith(${transpile(node.args[0], ctx)}, ${transpile(node.args[1], ctx)})`;
+                }
+                break;
+            case 'normalize-space':
+                if (node.args?.length === 1) {
+                    return `trim(${transpile(node.args[0], ctx)})`;
                 }
                 break;
             case 'not':
                 if (node.args?.length === 1) {
-                    return `!(${transpile(node.args[0], lookupAnswerCode)})`;
+                    return `!(${transpile(node.args[0], ctx)})`;
                 }
                 break;
             case 'if':
+                // Use if() function instead of ternary (? :) because EM's ternary parser
+                // can misinterpret colons inside string literals (e.g. '2026-03-CHW: Chancenwerk')
                 if (node.args?.length === 3) {
-                    return `(${transpile(node.args[0], lookupAnswerCode)} ? ${transpile(node.args[1], lookupAnswerCode)} : ${transpile(node.args[2], lookupAnswerCode)})`;
+                    return `if(${transpile(node.args[0], ctx)}, ${transpile(node.args[1], ctx)}, ${transpile(node.args[2], ctx)})`;
                 }
                 break;
             case 'today':
@@ -146,15 +154,16 @@ function transpile(node, lookupAnswerCode) {
                 throw new Error(`Unsupported function: ${node.id}`);
         }
     }
-    // https://getodk.github.io/xforms-spec/#xpath-operators 
+    // https://getodk.github.io/xforms-spec/#xpath-operators
     // to https://www.limesurvey.org/manual/ExpressionScript_-_Presentation (see syntax)
     if (node.type) {
+        const lookupAnswerCode = ctx?.lookupAnswerCode;
         switch (node.type) {
             // Comparison operators
             case '<=':
-                return `${transpile(node.left, lookupAnswerCode)} <= ${transpile(node.right, lookupAnswerCode)}`;
+                return `${transpile(node.left, ctx)} <= ${transpile(node.right, ctx)}`;
             case '>=':
-                return `${transpile(node.left, lookupAnswerCode)} >= ${transpile(node.right, lookupAnswerCode)}`;
+                return `${transpile(node.left, ctx)} >= ${transpile(node.right, ctx)}`;
             case '=':
             case '==': {
                 const leftNode = node.left;
@@ -164,10 +173,10 @@ function transpile(node, lookupAnswerCode) {
                     const rawValue = rightNode.value;
                     const rewritten = lookupAnswerCode(fieldName, rawValue);
                     if (rewritten !== rawValue) {
-                        return `${fieldName} == "${rewritten}"`;
+                        return `${fieldName} == '${rewritten}'`;
                     }
                 }
-                return `${transpile(leftNode, lookupAnswerCode)} == ${transpile(rightNode, lookupAnswerCode)}`;
+                return `${transpile(leftNode, ctx)} == ${transpile(rightNode, ctx)}`;
             }
             case '!=': {
                 const leftNode = node.left;
@@ -177,31 +186,31 @@ function transpile(node, lookupAnswerCode) {
                     const rawValue = rightNode.value;
                     const rewritten = lookupAnswerCode(fieldName, rawValue);
                     if (rewritten !== rawValue) {
-                        return `${fieldName} != "${rewritten}"`;
+                        return `${fieldName} != '${rewritten}'`;
                     }
                 }
-                return `${transpile(leftNode, lookupAnswerCode)} != ${transpile(rightNode, lookupAnswerCode)}`;
+                return `${transpile(leftNode, ctx)} != ${transpile(rightNode, ctx)}`;
             }
             case '<':
-                return `${transpile(node.left, lookupAnswerCode)} < ${transpile(node.right, lookupAnswerCode)}`;
+                return `${transpile(node.left, ctx)} < ${transpile(node.right, ctx)}`;
             case '>':
-                return `${transpile(node.left, lookupAnswerCode)} > ${transpile(node.right, lookupAnswerCode)}`;
+                return `${transpile(node.left, ctx)} > ${transpile(node.right, ctx)}`;
             // Arithmetic operators
             case '+':
-                return `${transpile(node.left, lookupAnswerCode)} + ${transpile(node.right, lookupAnswerCode)}`;
+                return `${transpile(node.left, ctx)} + ${transpile(node.right, ctx)}`;
             case '-':
-                return `${transpile(node.left, lookupAnswerCode)} - ${transpile(node.right, lookupAnswerCode)}`;
+                return `${transpile(node.left, ctx)} - ${transpile(node.right, ctx)}`;
             case '*':
-                return `${transpile(node.left, lookupAnswerCode)} * ${transpile(node.right, lookupAnswerCode)}`;
+                return `${transpile(node.left, ctx)} * ${transpile(node.right, ctx)}`;
             case 'div':
-                return `${transpile(node.left, lookupAnswerCode)} / ${transpile(node.right, lookupAnswerCode)}`;
+                return `${transpile(node.left, ctx)} / ${transpile(node.right, ctx)}`;
             case 'mod':
-                return `${transpile(node.left, lookupAnswerCode)} % ${transpile(node.right, lookupAnswerCode)}`;
+                return `${transpile(node.left, ctx)} % ${transpile(node.right, ctx)}`;
             // Logical operators
             case 'and':
-                return `${transpile(node.left, lookupAnswerCode)} and ${transpile(node.right, lookupAnswerCode)}`;
+                return `${transpile(node.left, ctx)} and ${transpile(node.right, ctx)}`;
             case 'or':
-                return `${transpile(node.left, lookupAnswerCode)} or ${transpile(node.right, lookupAnswerCode)}`;
+                return `${transpile(node.left, ctx)} or ${transpile(node.right, ctx)}`;
             // Unsupported operators
             case '|':
             case '/':
@@ -251,7 +260,7 @@ function transpile(node, lookupAnswerCode) {
  * @param xpathExpr - The XPath expression to convert
  * @returns LimeSurvey Expression Manager syntax, or null if conversion fails
  */
-export async function xpathToLimeSurvey(xpathExpr, lookupAnswerCode) {
+export async function xpathToLimeSurvey(xpathExpr, ctx) {
     if (!xpathExpr || xpathExpr.trim() === '') {
         return '1'; // Default relevance expression
     }
@@ -273,7 +282,7 @@ export async function xpathToLimeSurvey(xpathExpr, lookupAnswerCode) {
             throw new Error('js-xpath module does not export parse function');
         }
         const parsed = jxpath.parse(processedExpr);
-        return transpile(parsed, lookupAnswerCode);
+        return transpile(parsed, ctx);
     }
     catch (error) {
         console.error(`Transpilation error: ${error.message}`);
@@ -417,14 +426,14 @@ function parseRegexMatchArguments(argsString) {
  * @param xpath - The XPath relevance expression
  * @returns LimeSurvey Expression Manager syntax
  */
-export async function convertRelevance(xpathExpr, lookupAnswerCode) {
+export async function convertRelevance(xpathExpr, ctx) {
     if (!xpathExpr)
         return '1';
     // Preprocess: normalize operators to lowercase for jsxpath compatibility
     let normalizedXPath = xpathExpr
         .replace(/\bAND\b/gi, 'and')
         .replace(/\bOR\b/gi, 'or');
-    const result = await xpathToLimeSurvey(normalizedXPath, lookupAnswerCode);
+    const result = await xpathToLimeSurvey(normalizedXPath, ctx);
     // Handle edge case: selected() with just {field} (without $)
     if (result && result.includes('selected(')) {
         return result.replace(/selected\s*\(\s*\{(\w+)\}\s*,\s*["']([^'"]+)["']\s*\)/g, (_match, fieldName, value) => {

package/dist/processors/TSVGenerator.js

@@ -20,11 +20,12 @@ export class TSVGenerator {
             'mandatory',
             'other',
             'default',
-            'same_default'
+            'same_default',
+            'hidden'
         ];
         const lines = [headers.join('\t')];
         for (const row of this.rows) {
-            const values = headers.map((h) => this.escapeForTSV(row[h] || ''));
+            const values = headers.map((h) => this.escapeForTSV(row[h] ?? ''));
             lines.push(values.join('\t'));
         }
         return lines.join('\n');

package/dist/processors/TypeMapper.js

@@ -20,6 +20,7 @@ export const TYPE_MAPPINGS = {
     select_multiple: { limeSurveyType: 'M', supportsOther: true, answerClass: 'SQ' },
     // Other types
     note: { limeSurveyType: 'X' },
+    calculate: { limeSurveyType: '*' },
     rank: { limeSurveyType: 'R', answerClass: 'A', supportsOther: true },
 };
 export class TypeMapper {

package/dist/xlsformConverter.js

@@ -1,5 +1,5 @@
 import { ConfigManager } from './config/ConfigManager.js';
-import { convertRelevance, convertConstraint } from './converters/xpathTranspiler.js';
+import { convertRelevance, convertConstraint, xpathToLimeSurvey } from './converters/xpathTranspiler.js';
 import { FieldSanitizer } from './processors/FieldSanitizer.js';
 import { TSVGenerator } from './processors/TSVGenerator.js';
 import { TypeMapper } from './processors/TypeMapper.js';
@@ -7,7 +7,7 @@ import { getBaseLanguage } from './utils/languageUtils.js';
 // Metadata types that should be silently skipped (no visual representation)
 const SKIP_TYPES = [
     'start', 'end', 'today', 'deviceid', 'username',
-    'calculate', 'hidden', 'audit'
+    'hidden', 'audit'
 ];
 // Unimplemented XLSForm types that should raise an error
 const UNIMPLEMENTED_TYPES = [
@@ -51,6 +51,7 @@ export class XLSFormToTSVConverter {
         this.groupContentBuffer = [];
         this.answerCodeMap = new Map();
         this.questionToListMap = new Map();
+        this.questionBaseTypeMap = new Map();
     }
     /**
      * Get the current configuration
@@ -201,11 +202,13 @@ export class XLSFormToTSVConverter {
     }
     buildQuestionToListMap(surveyData) {
         this.questionToListMap = new Map();
+        this.questionBaseTypeMap = new Map();
         for (const row of surveyData) {
             const typeInfo = this.parseType(row.type || '');
             if (typeInfo.listName && row.name) {
                 const sanitizedName = this.sanitizeName(row.name.trim());
                 this.questionToListMap.set(sanitizedName, typeInfo.listName);
+                this.questionBaseTypeMap.set(sanitizedName, typeInfo.base);
             }
         }
     }
@@ -537,6 +540,21 @@ export class XLSFormToTSVConverter {
     sanitizeAnswerCode(code) {
         return this.fieldSanitizer.sanitizeAnswerCode(code);
     }
+    /**
+     * Convert ${varname} references in text to LimeSurvey EM syntax {sanitizedname}.
+     */
+    convertVariableReferences(text) {
+        return text.replace(/\$\{([^}]+)\}/g, (_, name) => {
+            const sanitized = name.replace(/[_-]/g, '');
+            return `{${sanitized}}`;
+        });
+    }
+    /**
+     * Transpile an XLSForm calculation expression to a LimeSurvey EM expression.
+     */
+    async convertCalculation(calculation) {
+        return await xpathToLimeSurvey(calculation, this.buildTranspilerContext());
+    }
     async addGroup(row) {
         // Auto-generate name if missing (matches LimeSurvey behavior)
         const groupName = row.name && row.name.trim() !== ''
@@ -554,10 +572,10 @@ export class XLSFormToTSVConverter {
             this.tsvGenerator.addRow({
                 class: 'G',
                 'type/scale': groupSeqKey,
-                name: groupName,
+                name: this.getLanguageSpecificValue(row.label, lang) || groupName,
                 relevance: await this.convertRelevance(row.relevant),
-                text: this.getLanguageSpecificValue(row.label, lang) || groupName,
-                help: this.getLanguageSpecificValue(row.hint, lang) || '',
+                text: this.getLanguageSpecificValue(row.hint, lang) || '',
+                help: '',
                 language: lang,
                 validation: '',
                 em_validation_q: "",
@@ -609,22 +627,40 @@ export class XLSFormToTSVConverter {
         }
         // Notes have special handling
         const isNote = xfTypeInfo.base === 'note';
+        const isCalculate = xfTypeInfo.base === 'calculate';
+        // For calculate type, transpile the calculation expression to EM syntax
+        let calculationExpr = '';
+        if (isCalculate && row.calculation) {
+            calculationExpr = await this.convertCalculation(row.calculation);
+        }
         // Add main question for each language
         for (const lang of this.availableLanguages) {
+            let text;
+            if (isCalculate) {
+                // Equation question: the EM expression wrapped in {} IS the question text
+                text = `{${calculationExpr}}`;
+            }
+            else {
+                text = this.getLanguageSpecificValue(row.label, lang) || questionName;
+            }
+            // Convert ${var} references to EM {var} syntax in text and help
+            text = this.convertVariableReferences(text);
+            const help = this.convertVariableReferences(this.getLanguageSpecificValue(row.hint, lang) || '');
             this.bufferRow({
                 class: 'Q',
                 'type/scale': isNote ? 'X' : lsType.type,
                 name: questionName,
                 relevance: await this.convertRelevance(row.relevant),
-                text: this.getLanguageSpecificValue(row.label, lang) || questionName,
-                help: this.getLanguageSpecificValue(row.hint, lang) || '',
+                text,
+                help,
                 language: lang,
                 validation: "",
-                em_validation_q: isNote ? "" : await convertConstraint(row.constraint || ""),
-                mandatory: isNote ? '' : (row.required === 'yes' || row.required === 'true' ? 'Y' : ''),
-                other: isNote ? '' : (lsType.other ? 'Y' : ''),
-                default: isNote ? '' : (row.default || ''),
-                same_default: ''
+                em_validation_q: (isNote || isCalculate) ? "" : await convertConstraint(row.constraint || ""),
+                mandatory: (isNote || isCalculate) ? '' : (row.required === 'yes' || row.required === 'true' ? 'Y' : ''),
+                other: (isNote || isCalculate) ? '' : (lsType.other ? 'Y' : ''),
+                default: (isNote || isCalculate) ? '' : (row.default || ''),
+                same_default: '',
+                hidden: isCalculate ? '1' : '',
             });
         }
         // Reset answer sequence for this question
@@ -784,20 +820,37 @@ export class XLSFormToTSVConverter {
             }
         }
     }
+    lookupAnswerCode(fieldName, choiceValue) {
+        // Truncate to 20 chars to match converter's field sanitization
+        // (the transpiler only removes _/- but doesn't truncate)
+        const truncated = fieldName.length > 20 ? fieldName.substring(0, 20) : fieldName;
+        const listName = this.questionToListMap.get(truncated);
+        if (!listName)
+            return { code: choiceValue, listName: undefined };
+        const codeMap = this.answerCodeMap.get(listName);
+        if (!codeMap)
+            return { code: choiceValue, listName };
+        return { code: codeMap.get(choiceValue) ?? choiceValue, listName };
+    }
+    buildTranspilerContext() {
+        return {
+            lookupAnswerCode: (fieldName, choiceValue) => {
+                return this.lookupAnswerCode(fieldName, choiceValue).code;
+            },
+            buildSelectedExpr: (fieldName, choiceValue) => {
+                const truncated = fieldName.length > 20 ? fieldName.substring(0, 20) : fieldName;
+                const { code } = this.lookupAnswerCode(fieldName, choiceValue);
+                const baseType = this.questionBaseTypeMap.get(truncated);
+                if (baseType === 'select_multiple') {
+                    return `(${truncated}_${code}.NAOK == 'Y')`;
+                }
+                return `(${truncated}.NAOK=='${code}')`;
+            },
+        };
+    }
     async convertRelevance(relevant) {
         if (!relevant)
             return '1';
-        return await convertRelevance(relevant, (questionName, choiceValue) => {
-            // Truncate to 20 chars to match converter's field sanitization
-            // (the transpiler only removes _/- but doesn't truncate)
-            const truncated = questionName.length > 20 ? questionName.substring(0, 20) : questionName;
-            const listName = this.questionToListMap.get(truncated);
-            if (!listName)
-                return choiceValue;
-            const codeMap = this.answerCodeMap.get(listName);
-            if (!codeMap)
-                return choiceValue;
-            return codeMap.get(choiceValue) ?? choiceValue;
-        });
+        return await convertRelevance(relevant, this.buildTranspilerContext());
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xlsform2lstsv",
-  "version": "0.2.2",
+  "version": "0.3.0",
   "description": "Convert XLSForm surveys to LimeSurvey TSV format",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",