babelfhir-ts 1.4.0 → 1.4.1

package/README.md

@@ -240,7 +240,9 @@ Options:
   --registry <url>         FHIR package registry URL (default: https://packages.simplifier.net)
   --tx-server <url>        Terminology server URL for ValueSet expansion (e.g., https://tx.fhir.org/r4)
                            When set, expands ValueSets without explicit codes using $expand operation
-  --display-language <lang> BCP-47 language for display terms (e.g., de, fr). Passed to $expand displayLanguage
+  --display-language <lang> BCP-47 language(s) for display terms (e.g., de or de,fr,en).
+                           Single value replaces concept displays. Comma-separated values
+                           also generate a multi-language display map with getDisplay() helper.
 
 Examples:
   babelfhir-ts                                             # Process ./input to ./output

package/out/src/cli/updateCommand.js

@@ -10,6 +10,7 @@
  *   babelfhir-ts update <package-name@version>   # update a single package
  */
 import fs from 'fs';
+import os from 'os';
 import path from 'path';
 import crypto from 'crypto';
 import { generateIntoPackageDirect, resetFetchFailureTracking } from '../generator/index.js';
@@ -73,6 +74,10 @@ export async function handleUpdateCommand(opts) {
     if (updatedPackages.length > 0) {
         patchBunLockIntegrity(updatedPackages);
     }
+    // 5b. Remove stale node_modules/<pkg> so bun re-extracts from the updated tgz
+    if (updatedPackages.length > 0) {
+        removeStaleNodeModules(updatedPackages.map((p) => p.generatedName));
+    }
     // 6. Single npm install at the end
     if (updated > 0) {
         console.log('\nReinstalling dependencies...');
@@ -298,8 +303,21 @@ export function patchBunLockIntegrity(updatedPackages) {
     const pm = detectPackageManager();
     if (!pm.cmd.includes('bun'))
         return;
-    const lockPath = path.resolve('bun.lock');
-    if (!fs.existsSync(lockPath))
+    // Walk up to find bun.lock (in monorepos it's at the workspace root, not cwd)
+    let lockPath = null;
+    let dir = process.cwd();
+    while (true) {
+        const candidate = path.join(dir, 'bun.lock');
+        if (fs.existsSync(candidate)) {
+            lockPath = candidate;
+            break;
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    if (!lockPath)
         return;
     let lockContent = fs.readFileSync(lockPath, 'utf8');
     let patched = 0;
@@ -348,6 +366,71 @@ function clearBunCacheForPackage(packageName) {
         dir = parent;
     }
 }
+/**
+ * Remove node_modules/<pkg> directories, bun cached extractions, and bun global
+ * cache entries for each updated package so bun re-extracts from the fresh tgz.
+ * Finds the workspace root first, then cleans all node_modules dirs from cwd up.
+ */
+function removeStaleNodeModules(packageNames) {
+    // Find the workspace root: highest ancestor with a package.json
+    let root = process.cwd();
+    let search = root;
+    while (true) {
+        const parent = path.dirname(search);
+        if (parent === search)
+            break;
+        if (fs.existsSync(path.join(parent, 'package.json')))
+            root = parent;
+        search = parent;
+    }
+    // Walk from cwd up to (and including) the root, cleaning each node_modules
+    let dir = process.cwd();
+    while (true) {
+        const nm = path.join(dir, 'node_modules');
+        for (const name of packageNames) {
+            // Remove the symlink / junction / directory itself (lstat detects dangling junctions too)
+            const pkgDir = path.join(nm, name);
+            let pkgExists = false;
+            try {
+                fs.lstatSync(pkgDir);
+                pkgExists = true;
+            }
+            catch { /* does not exist */ }
+            if (pkgExists) {
+                fs.rmSync(pkgDir, { recursive: true, force: true });
+            }
+            // Remove bun's content-addressed cache entries (node_modules/.bun/<pkg>@*)
+            const bunDir = path.join(nm, '.bun');
+            if (fs.existsSync(bunDir)) {
+                const prefix = `${name}@`;
+                try {
+                    for (const entry of fs.readdirSync(bunDir, { withFileTypes: true })) {
+                        if (entry.isDirectory() && entry.name.startsWith(prefix)) {
+                            fs.rmSync(path.join(bunDir, entry.name), { recursive: true, force: true });
+                        }
+                    }
+                }
+                catch { /* ignore read errors */ }
+            }
+        }
+        if (dir === root)
+            break;
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    // Clear bun's global install cache (~/.bun/install/cache/<pkg>)
+    const bunGlobalCache = path.join(os.homedir(), '.bun', 'install', 'cache');
+    if (fs.existsSync(bunGlobalCache)) {
+        for (const name of packageNames) {
+            const cached = path.join(bunGlobalCache, name);
+            if (fs.existsSync(cached)) {
+                fs.rmSync(cached, { recursive: true, force: true });
+            }
+        }
+    }
+}
 // ── Package manager install ─────────────────────────────────────────────────
 function runInstall() {
     return new Promise((resolve, reject) => {

package/out/src/generator/emitters/valueset/valueSetGenerator.js

@@ -5,7 +5,7 @@
 /**
  * Generate TypeScript content for a ValueSet
  */
-export function generateValueSetTypeScript(valueSet) {
+export function generateValueSetTypeScript(valueSet, options) {
     const sanitizedName = sanitizeValueSetName(valueSet.name);
     const filename = `ValueSet-${sanitizedName}.ts`;
     // Use the already-computed isSmall flag from vsParser (uses VALUESET_THRESHOLDS.UNION_TYPE)
@@ -88,6 +88,20 @@ export function generateValueSetTypeScript(valueSet) {
         // For empty ValueSets, add a note
         content += `/**\n * Note: This ValueSet has no explicitly enumerated codes.\n * It may be defined by filters or external terminology.\n * Runtime validation is not available for this ValueSet.\n */\n`;
     }
+    // Generate multi-language display map if translations are provided
+    const translations = options?.displayTranslations;
+    if (translations && translations.size > 0) {
+        content += `\n/**\n * Multi-language display translations\n * Maps code → language → display string\n */\n`;
+        content += `export const ${sanitizedName}Displays: Record<string, Record<string, string>> = {\n`;
+        for (const [code, langs] of translations) {
+            content += `  ${JSON.stringify(code)}: ${JSON.stringify(langs)},\n`;
+        }
+        content += `};\n\n`;
+        content += `/**\n * Get the display string for a code in a specific language\n */\n`;
+        content += `export function get${sanitizedName}Display(code: string, lang: string): string | undefined {\n`;
+        content += `  return ${sanitizedName}Displays[code]?.[lang];\n`;
+        content += `}\n`;
+    }
     return { filename, content };
 }
 /**

package/out/src/generator/generationHelpers.js

@@ -107,8 +107,12 @@ export function collectReferencedDependencyProfiles(mainSDs, dependencySDs) {
  * Used by generate() and generateIntoPackage() when --tx-server is specified.
  */
 export async function expandValueSetsWithTx(valueSets, valueSetCodesMap, structureDefinitions, txServer, displayLanguage) {
+    // Parse comma-separated languages: first is primary, multiple trigger display map
+    const langs = displayLanguage?.split(',').map(l => l.trim()).filter(Boolean) ?? [];
+    const primaryLang = langs[0];
+    const multiLangs = langs.length > 1 ? langs : undefined;
     const cacheDir = getCacheConfig().rootDir;
-    const txClient = createTxClient(cacheDir, txServer, displayLanguage);
+    const txClient = createTxClient(cacheDir, txServer, primaryLang);
     const bindingUrls = collectValueSetBindingUrls(structureDefinitions);
     logger.log(`Found ${bindingUrls.size} unique ValueSet bindings in StructureDefinitions`);
     addPlaceholdersForExternalBindings(valueSets, bindingUrls, getFhirPackagesCacheDir());
@@ -123,6 +127,55 @@ export async function expandValueSetsWithTx(valueSets, valueSetCodesMap, structu
         }
     }
     logger.log(`After tx expansion: ${expanded.size} ValueSets (${Array.from(expanded.values()).filter(vs => vs.concepts.length > 0).length} with codes)`);
+    // Multi-language display expansion
+    if (multiLangs && multiLangs.length > 0) {
+        const multiLangClient = createTxClient(cacheDir, txServer);
+        let translatedCount = 0;
+        let totalCodes = 0;
+        let untranslatedCodes = 0;
+        for (const [url, vs] of expanded) {
+            if (vs.concepts.length === 0)
+                continue;
+            const translations = await multiLangClient.expandValueSetMultiLang(url, multiLangs);
+            if (translations.size === 0)
+                continue;
+            // Build canonical display lookup from the primary expansion
+            const canonicalDisplay = new Map();
+            for (const concept of vs.concepts) {
+                if (concept.display)
+                    canonicalDisplay.set(concept.code, concept.display);
+            }
+            // Strip languages where the tx server returned the same text as the
+            // canonical (English) display — this means no real translation exists.
+            for (const [code, langMap] of translations) {
+                const baseline = canonicalDisplay.get(code);
+                totalCodes++;
+                let hasRealTranslation = false;
+                for (const lang of Object.keys(langMap)) {
+                    if (!baseline || langMap[lang] === baseline) {
+                        delete langMap[lang];
+                    }
+                    else {
+                        hasRealTranslation = true;
+                    }
+                }
+                if (!hasRealTranslation) {
+                    translations.delete(code);
+                    untranslatedCodes++;
+                }
+            }
+            if (translations.size > 0) {
+                vs.displayTranslations = translations;
+                translatedCount++;
+            }
+        }
+        if (translatedCount > 0) {
+            logger.log(`Generated multi-language display maps for ${translatedCount} ValueSets (${multiLangs.join(', ')})`);
+        }
+        if (untranslatedCodes > 0) {
+            logger.warn(`${untranslatedCodes}/${totalCodes} codes had no translations (tx server returned English for all requested languages)`);
+        }
+    }
     return expanded;
 }
 /**
@@ -145,7 +198,9 @@ export function emitValueSetFiles(valueSets, outputDir, opts) {
             if (generatedCount === 0) {
                 ensureDirectoryExists(valueSetOutputDir);
             }
-            let { filename, content } = generateValueSetTypeScript(valueSet);
+            let { filename, content } = generateValueSetTypeScript(valueSet, {
+                displayTranslations: valueSet.displayTranslations,
+            });
             // Handle duplicate filenames by appending a number
             if (usedFilenames) {
                 const baseFilename = filename.replace('.ts', '');

package/out/src/generator/index.js

@@ -652,6 +652,7 @@ export async function generateIntoPackageDirect(packageArchivePath, flags) {
             ...(originalPkg.canonical && { canonical: originalPkg.canonical }),
             ...(originalPkg.fhirVersions && { fhirVersions: originalPkg.fhirVersions }),
             ...(flags?.txServer && { txServer: flags.txServer }),
+            ...(flags?.displayLanguage && { displayLanguage: flags.displayLanguage }),
             ...(flags?.dicomweb && { dicomweb: true }),
             ...(flags?.noClient && { noClient: true }),
             ...(flags?.noClasses && { noClasses: true }),

package/out/src/generator/parser/txClient.js

@@ -159,6 +159,56 @@ export class TxClient {
         }
         return results;
     }
+    /**
+     * Expand a single ValueSet in multiple languages, returning a display map.
+     * @returns Map<code, Record<lang, display>>
+     */
+    async expandValueSetMultiLang(valueSetUrl, languages) {
+        const displayMap = new Map();
+        for (const lang of languages) {
+            const langParam = `&displayLanguage=${encodeURIComponent(lang)}`;
+            const expandUrl = `${this.txServer}/ValueSet/$expand?url=${encodeURIComponent(valueSetUrl)}&count=${this.maxCodes}${langParam}`;
+            try {
+                const controller = new AbortController();
+                const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+                const response = await fetch(expandUrl, {
+                    method: 'GET',
+                    headers: {
+                        'Accept': 'application/fhir+json',
+                        'User-Agent': USER_AGENT,
+                    },
+                    signal: controller.signal,
+                });
+                clearTimeout(timeoutId);
+                if (!response.ok) {
+                    log.warn(`Failed to expand ${valueSetUrl} for lang=${lang}: HTTP ${response.status}`);
+                    continue;
+                }
+                const valueSet = await response.json();
+                if (valueSet.expansion?.contains) {
+                    for (const item of valueSet.expansion.contains) {
+                        if (!item.display)
+                            continue;
+                        let entry = displayMap.get(item.code);
+                        if (!entry) {
+                            entry = {};
+                            displayMap.set(item.code, entry);
+                        }
+                        entry[lang] = item.display;
+                    }
+                }
+            }
+            catch (err) {
+                if (err instanceof Error && err.name === 'AbortError') {
+                    log.warn(`Timeout expanding ${valueSetUrl} for lang=${lang}`);
+                }
+                else {
+                    log.warn(`Error expanding ${valueSetUrl} for lang=${lang}: ${err}`);
+                }
+            }
+        }
+        return displayMap;
+    }
     /**
      * Get statistics about cached expansions
      */

package/out/src/generator/parser/vsParser.js

@@ -129,10 +129,14 @@ export function getUniformSystem(valueSet) {
  * @returns Updated map with expanded concepts
  */
 export async function expandValueSetsFromTx(valueSets, txClient) {
-    // Find ValueSets that need expansion (have URL but no concepts)
+    // Find ValueSets that need expansion:
+    // - No concepts yet (always expand)
+    // - Has concepts but displayLanguage is set (re-expand to get translated displays)
     const needsExpansion = [];
     for (const [url, vs] of valueSets) {
-        if (vs.concepts.length === 0 && url) {
+        if (!url)
+            continue;
+        if (vs.concepts.length === 0 || txClient.displayLanguage) {
             needsExpansion.push(url);
         }
     }

package/out/src/main.js

@@ -64,7 +64,9 @@ function printUsage() {
     console.log("  --registry <url>         FHIR package registry URL (default: https://packages.simplifier.net)");
     console.log("  --tx-server <url>        Terminology server URL for ValueSet expansion (e.g., https://tx.fhir.org/r4)");
     console.log("                           When set, expands ValueSets without explicit codes using $expand operation");
-    console.log("  --display-language <lang> BCP-47 language for display terms (e.g., de, fr). Passed to $expand displayLanguage");
+    console.log("  --display-language <lang> BCP-47 language(s) for display terms (e.g., de or de,fr,en).");
+    console.log("                           Single value replaces concept displays. Comma-separated values");
+    console.log("                           also generate a multi-language display map with getDisplay() helper.");
     console.log("");
     console.log("Examples:");
     console.log("  babelfhir-ts                                             # Process ./input to ./output");
@@ -293,7 +295,7 @@ export function parseCliArgs(argv) {
             i++;
             continue;
         }
-        if (arg === '--display-language') {
+        if (arg === '--display-language' || arg === '--display-languages') {
             const val = argv[i + 1];
             if (!val || val.startsWith('-'))
                 throw new Error('Missing value for --display-language');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "babelfhir-ts",
-  "version": "1.4.0",
+  "version": "1.4.1",
   "description": "BabelFHIR-TS: generate TypeScript interfaces, validators, and helper classes from FHIR R4/R4B/R5 StructureDefinitions (profiles) directly inside package archives.",
   "type": "module",
   "main": "out/src/main.js",