xlsform2lstsv 0.2.0 → 0.2.2

package/dist/converters/xpathTranspiler.js

@@ -7,6 +7,12 @@
  * The transpiler uses js-xpath library to parse XPath expressions into AST,
  * then recursively transforms the AST nodes to LimeSurvey-compatible syntax.
  */
+function isVariableRef(node) {
+    return !!(node.steps && node.steps.length > 0 && node.steps[0].name);
+}
+function isStringLiteral(node) {
+    return typeof node.value === 'string';
+}
 /**
  * Sanitize field names by removing underscores and hyphens to match LimeSurvey's naming conventions
  */
@@ -32,7 +38,7 @@ function sanitizeName(name) {
  * @returns The transpiled LimeSurvey expression string
  * @throws Error if an unsupported node structure is encountered
  */
-function transpile(node) {
+function transpile(node, lookupAnswerCode) {
     if (!node)
         return '';
     // https://getodk.github.io/xforms-spec/#xpath-functions
@@ -40,15 +46,15 @@ function transpile(node) {
     if (node.id) {
         switch (node.id) {
             case 'count':
-                return `count(${node.args?.map(arg => transpile(arg)).join(', ') || ''})`;
+                return `count(${node.args?.map(arg => transpile(arg, lookupAnswerCode)).join(', ') || ''})`;
             case 'concat':
-                return node.args?.map(arg => transpile(arg)).join(' + ') || '';
+                return node.args?.map(arg => transpile(arg, lookupAnswerCode)).join(' + ') || '';
             case 'regex':
-                return `regexMatch(${node.args?.map(arg => transpile(arg)).join(', ') || ''})`;
+                return `regexMatch(${node.args?.map(arg => transpile(arg, lookupAnswerCode)).join(', ') || ''})`;
             case 'contains':
                 // Custom handling for contains
                 if (node.args?.length === 2) {
-                    return `contains(${transpile(node.args[0])}, ${transpile(node.args[1])})`;
+                    return `contains(${transpile(node.args[0], lookupAnswerCode)}, ${transpile(node.args[1], lookupAnswerCode)})`;
                 }
                 break;
             case 'selected':
@@ -56,76 +62,80 @@ function transpile(node) {
                 if (node.args?.length === 2) {
                     const fieldArg = node.args[0];
                     const valueArg = node.args[1];
-                    const fieldName = transpile(fieldArg);
-                    let value = transpile(valueArg);
+                    const fieldName = transpile(fieldArg, lookupAnswerCode);
+                    let value = transpile(valueArg, lookupAnswerCode);
                     // Remove any existing quotes and use double quotes
                     value = value.replace(/^['"]|['"]$/g, "");
-                    return `(${sanitizeName(fieldName)}=="${value}")`;
+                    const sanitizedField = sanitizeName(fieldName);
+                    if (lookupAnswerCode) {
+                        value = lookupAnswerCode(sanitizedField, value);
+                    }
+                    return `(${sanitizedField}=="${value}")`;
                 }
                 break;
             case 'string':
                 // string() function - just return the argument
                 if (node.args?.length === 1) {
-                    return transpile(node.args[0]);
+                    return transpile(node.args[0], lookupAnswerCode);
                 }
                 break;
             case 'number':
                 // number() function - just return the argument
                 if (node.args?.length === 1) {
-                    return transpile(node.args[0]);
+                    return transpile(node.args[0], lookupAnswerCode);
                 }
                 break;
             case 'floor':
                 if (node.args?.length === 1) {
-                    return `floor(${transpile(node.args[0])})`;
+                    return `floor(${transpile(node.args[0], lookupAnswerCode)})`;
                 }
                 break;
             case 'ceiling':
                 if (node.args?.length === 1) {
-                    return `ceil(${transpile(node.args[0])})`;
+                    return `ceil(${transpile(node.args[0], lookupAnswerCode)})`;
                 }
                 break;
             case 'round':
                 if (node.args?.length === 1) {
-                    return `round(${transpile(node.args[0])})`;
+                    return `round(${transpile(node.args[0], lookupAnswerCode)})`;
                 }
                 break;
             case 'sum':
                 if (node.args?.length === 1) {
-                    return `sum(${transpile(node.args[0])})`;
+                    return `sum(${transpile(node.args[0], lookupAnswerCode)})`;
                 }
                 break;
             case 'substring':
                 if (node.args && node.args.length >= 2) {
-                    const stringArg = transpile(node.args[0]);
-                    const startArg = transpile(node.args[1]);
-                    const lengthArg = node.args.length > 2 ? transpile(node.args[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) : '';
                     return `substr(${stringArg}, ${startArg}${lengthArg ? ', ' + lengthArg : ''})`;
                 }
                 break;
             case 'string-length':
                 if (node.args?.length === 1) {
-                    return `strlen(${transpile(node.args[0])})`;
+                    return `strlen(${transpile(node.args[0], lookupAnswerCode)})`;
                 }
                 break;
             case 'starts-with':
                 if (node.args?.length === 2) {
-                    return `startsWith(${transpile(node.args[0])}, ${transpile(node.args[1])})`;
+                    return `startsWith(${transpile(node.args[0], lookupAnswerCode)}, ${transpile(node.args[1], lookupAnswerCode)})`;
                 }
                 break;
             case 'ends-with':
                 if (node.args?.length === 2) {
-                    return `endsWith(${transpile(node.args[0])}, ${transpile(node.args[1])})`;
+                    return `endsWith(${transpile(node.args[0], lookupAnswerCode)}, ${transpile(node.args[1], lookupAnswerCode)})`;
                 }
                 break;
             case 'not':
                 if (node.args?.length === 1) {
-                    return `!(${transpile(node.args[0])})`;
+                    return `!(${transpile(node.args[0], lookupAnswerCode)})`;
                 }
                 break;
             case 'if':
                 if (node.args?.length === 3) {
-                    return `(${transpile(node.args[0])} ? ${transpile(node.args[1])} : ${transpile(node.args[2])})`;
+                    return `(${transpile(node.args[0], lookupAnswerCode)} ? ${transpile(node.args[1], lookupAnswerCode)} : ${transpile(node.args[2], lookupAnswerCode)})`;
                 }
                 break;
             case 'today':
@@ -142,34 +152,56 @@ function transpile(node) {
         switch (node.type) {
             // Comparison operators
             case '<=':
-                return `${transpile(node.left)} <= ${transpile(node.right)}`;
+                return `${transpile(node.left, lookupAnswerCode)} <= ${transpile(node.right, lookupAnswerCode)}`;
             case '>=':
-                return `${transpile(node.left)} >= ${transpile(node.right)}`;
+                return `${transpile(node.left, lookupAnswerCode)} >= ${transpile(node.right, lookupAnswerCode)}`;
             case '=':
-            case '==':
-                return `${transpile(node.left)} == ${transpile(node.right)}`;
-            case '!=':
-                return `${transpile(node.left)} != ${transpile(node.right)}`;
+            case '==': {
+                const leftNode = node.left;
+                const rightNode = node.right;
+                if (lookupAnswerCode && isVariableRef(leftNode) && isStringLiteral(rightNode)) {
+                    const fieldName = sanitizeName(leftNode.steps[0].name);
+                    const rawValue = rightNode.value;
+                    const rewritten = lookupAnswerCode(fieldName, rawValue);
+                    if (rewritten !== rawValue) {
+                        return `${fieldName} == "${rewritten}"`;
+                    }
+                }
+                return `${transpile(leftNode, lookupAnswerCode)} == ${transpile(rightNode, lookupAnswerCode)}`;
+            }
+            case '!=': {
+                const leftNode = node.left;
+                const rightNode = node.right;
+                if (lookupAnswerCode && isVariableRef(leftNode) && isStringLiteral(rightNode)) {
+                    const fieldName = sanitizeName(leftNode.steps[0].name);
+                    const rawValue = rightNode.value;
+                    const rewritten = lookupAnswerCode(fieldName, rawValue);
+                    if (rewritten !== rawValue) {
+                        return `${fieldName} != "${rewritten}"`;
+                    }
+                }
+                return `${transpile(leftNode, lookupAnswerCode)} != ${transpile(rightNode, lookupAnswerCode)}`;
+            }
             case '<':
-                return `${transpile(node.left)} < ${transpile(node.right)}`;
+                return `${transpile(node.left, lookupAnswerCode)} < ${transpile(node.right, lookupAnswerCode)}`;
             case '>':
-                return `${transpile(node.left)} > ${transpile(node.right)}`;
+                return `${transpile(node.left, lookupAnswerCode)} > ${transpile(node.right, lookupAnswerCode)}`;
             // Arithmetic operators
             case '+':
-                return `${transpile(node.left)} + ${transpile(node.right)}`;
+                return `${transpile(node.left, lookupAnswerCode)} + ${transpile(node.right, lookupAnswerCode)}`;
             case '-':
-                return `${transpile(node.left)} - ${transpile(node.right)}`;
+                return `${transpile(node.left, lookupAnswerCode)} - ${transpile(node.right, lookupAnswerCode)}`;
             case '*':
-                return `${transpile(node.left)} * ${transpile(node.right)}`;
+                return `${transpile(node.left, lookupAnswerCode)} * ${transpile(node.right, lookupAnswerCode)}`;
             case 'div':
-                return `${transpile(node.left)} / ${transpile(node.right)}`;
+                return `${transpile(node.left, lookupAnswerCode)} / ${transpile(node.right, lookupAnswerCode)}`;
             case 'mod':
-                return `${transpile(node.left)} % ${transpile(node.right)}`;
+                return `${transpile(node.left, lookupAnswerCode)} % ${transpile(node.right, lookupAnswerCode)}`;
             // Logical operators
             case 'and':
-                return `${transpile(node.left)} and ${transpile(node.right)}`;
+                return `${transpile(node.left, lookupAnswerCode)} and ${transpile(node.right, lookupAnswerCode)}`;
             case 'or':
-                return `${transpile(node.left)} or ${transpile(node.right)}`;
+                return `${transpile(node.left, lookupAnswerCode)} or ${transpile(node.right, lookupAnswerCode)}`;
             // Unsupported operators
             case '|':
             case '/':
@@ -219,7 +251,7 @@ function transpile(node) {
  * @param xpathExpr - The XPath expression to convert
  * @returns LimeSurvey Expression Manager syntax, or null if conversion fails
  */
-export async function xpathToLimeSurvey(xpathExpr) {
+export async function xpathToLimeSurvey(xpathExpr, lookupAnswerCode) {
     if (!xpathExpr || xpathExpr.trim() === '') {
         return '1'; // Default relevance expression
     }
@@ -241,7 +273,7 @@ export async function xpathToLimeSurvey(xpathExpr) {
             throw new Error('js-xpath module does not export parse function');
         }
         const parsed = jxpath.parse(processedExpr);
-        return transpile(parsed);
+        return transpile(parsed, lookupAnswerCode);
     }
     catch (error) {
         console.error(`Transpilation error: ${error.message}`);
@@ -385,14 +417,14 @@ function parseRegexMatchArguments(argsString) {
  * @param xpath - The XPath relevance expression
  * @returns LimeSurvey Expression Manager syntax
  */
-export async function convertRelevance(xpathExpr) {
+export async function convertRelevance(xpathExpr, lookupAnswerCode) {
     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);
+    const result = await xpathToLimeSurvey(normalizedXPath, lookupAnswerCode);
     // 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/xlsformConverter.js

@@ -49,6 +49,8 @@ export class XLSFormToTSVConverter {
         this.inMatrix = false;
         this.matrixListName = null;
         this.groupContentBuffer = [];
+        this.answerCodeMap = new Map();
+        this.questionToListMap = new Map();
     }
     /**
      * Get the current configuration
@@ -84,6 +86,9 @@ export class XLSFormToTSVConverter {
         this.detectAvailableLanguages(surveyData, choicesData, settingsData);
         // Build choices map
         this.buildChoicesMap(choicesData);
+        // Build answer code and question-to-list maps for relevance rewriting
+        this.buildAnswerCodeMap();
+        this.buildQuestionToListMap(surveyData);
         // Add survey row (class S)
         this.addSurveyRow(settingsData[0] || {});
         // Check if we need a default group (if no groups are defined)
@@ -161,6 +166,49 @@ export class XLSFormToTSVConverter {
             this.choicesMap.get(listName).push(choice);
         }
     }
+    buildAnswerCodeMap() {
+        this.answerCodeMap = new Map();
+        for (const [listName, choices] of this.choicesMap) {
+            const codeMap = new Map();
+            const sanitized = [];
+            for (const choice of choices) {
+                const raw = choice.name?.trim() || '';
+                sanitized.push(raw ? this.sanitizeAnswerCode(raw) : '');
+            }
+            const used = new Set();
+            for (let i = 0; i < sanitized.length; i++) {
+                if (!sanitized[i])
+                    continue;
+                let name = sanitized[i];
+                if (used.has(name)) {
+                    let counter = 1;
+                    let candidate;
+                    do {
+                        const suffix = String(counter);
+                        candidate = name.substring(0, 5 - suffix.length) + suffix;
+                        counter++;
+                    } while (used.has(candidate));
+                    sanitized[i] = candidate;
+                }
+                used.add(sanitized[i]);
+                const originalName = choices[i].name?.trim() || '';
+                if (originalName) {
+                    codeMap.set(originalName, sanitized[i]);
+                }
+            }
+            this.answerCodeMap.set(listName, codeMap);
+        }
+    }
+    buildQuestionToListMap(surveyData) {
+        this.questionToListMap = 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);
+            }
+        }
+    }
     addDefaultGroup() {
         // Add a default group for surveys without explicit groups
         const defaults = this.configManager.getDefaults();
@@ -686,11 +734,34 @@ export class XLSFormToTSVConverter {
         }
         // Use the answer class from the type mapping
         const answerClass = lsType.answerClass || (xfTypeInfo.base === 'select_multiple' ? 'SQ' : 'A');
+        // Pre-compute sanitized choice names
+        const choiceNames = [];
         for (const choice of choices) {
-            // Auto-generate name if missing (matches LimeSurvey behavior)
-            const choiceName = choice.name && choice.name.trim() !== ''
-                ? this.sanitizeAnswerCode(choice.name.trim())
-                : (answerClass === 'SQ' ? `SQ${this.subquestionSeq++}` : `A${this.answerSeq++}`);
+            const rawName = choice.name && choice.name.trim() !== '' ? choice.name.trim() : '';
+            choiceNames.push(rawName
+                ? this.sanitizeAnswerCode(rawName)
+                : (answerClass === 'SQ' ? `SQ${this.subquestionSeq++}` : `A${this.answerSeq++}`));
+        }
+        // Resolve duplicate names by appending a counter suffix
+        const usedNames = new Set();
+        for (let i = 0; i < choiceNames.length; i++) {
+            let name = choiceNames[i];
+            if (usedNames.has(name)) {
+                let counter = 1;
+                let candidate;
+                do {
+                    const suffix = String(counter);
+                    candidate = name.substring(0, 5 - suffix.length) + suffix;
+                    counter++;
+                } while (usedNames.has(candidate));
+                console.warn(`Duplicate answer code "${name}" resolved to "${candidate}"`);
+                choiceNames[i] = candidate;
+            }
+            usedNames.add(choiceNames[i]);
+        }
+        for (let i = 0; i < choices.length; i++) {
+            const choice = choices[i];
+            const choiceName = choiceNames[i];
             // Add answer for each language
             for (const lang of this.availableLanguages) {
                 this.bufferRow({
@@ -716,6 +787,17 @@ export class XLSFormToTSVConverter {
     async convertRelevance(relevant) {
         if (!relevant)
             return '1';
-        return await convertRelevance(relevant);
+        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;
+        });
     }
 }

package/package.json

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