babelfhir-ts 1.6.8 → 1.6.10

package/out/src/generator/core/generatedPackageDeps.js

@@ -112,14 +112,24 @@ export const EMITTED_RANGES = {
     /**
      * Prefab UI runtime for `--prefab` output.
      *
-     * 0.3.0 is the floor: it introduced wire protocol 0.3, where the theme is
-     * compiled into the top-level `css` array, `stylesheets` carries external
-     * URLs, and `mode` forces a colour scheme. Emitted renderers pass `theme`
-     * and spread `PrefabAppOptions` into `PrefabApp`, so they rely on a >= 0.3
+     * 0.3.0 introduced wire protocol 0.3, where the theme is compiled into the
+     * top-level `css` array, `stylesheets` carries external URLs, and `mode`
+     * forces a colour scheme. Emitted renderers pass `theme` and spread
+     * `PrefabAppOptions` into `PrefabApp`, so they rely on a >= 0.3
      * serializer/renderer pair to apply themes. A 0.2.x renderer would silently
      * drop them.
+     *
+     * 0.3.12 is the floor, for what the emitted form puts on a coded field.
+     * `AutoFormField` gained `options` in 0.3.10 — below that the property is not
+     * in the type, `autoForm` ignores it, and a bound field renders as free text.
+     * 0.3.12 then moved `required` onto every stateful control and added
+     * `Select({ multiple })`: before it, `autoForm` dropped `required` on the
+     * Select path because the component could not carry it, and a repeating coded
+     * element had no multi-select to render as. On 0.3.10 or 0.3.11 the form still
+     * builds and still offers the right choices, but a required element is not
+     * marked required and a repeating one takes a single value.
      */
-    prefab: '^0.3.0',
+    prefab: '^0.3.12',
     /**
      * Generated FHIR client base package (`@babelfhir-ts/client-<slug>`).
      *

package/out/src/generator/core/utils.js

@@ -341,6 +341,32 @@ export function mergeFields(newFields, oldFields) {
     // Return the merged fields as an array
     return Array.from(fieldMap.values());
 }
+/**
+ * Copies a directory tree, optionally keeping only the files a predicate accepts.
+ *
+ * Shared by the compile-time dependency providers, which each need part of an
+ * installed package inside the output's `node_modules` — the zod runtime whole,
+ * prefab's declarations only.
+ *
+ * @param filter - Called per file with its absolute source path. Omit to copy everything.
+ *                 A directory left empty by the filter is not created.
+ */
+export function copyDirRecursive(src, dest, filter) {
+    for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+        if (entry.isDirectory()) {
+            fs.mkdirSync(destPath, { recursive: true });
+            copyDirRecursive(srcPath, destPath, filter);
+            if (fs.readdirSync(destPath).length === 0)
+                fs.rmdirSync(destPath);
+        }
+        else if (!filter || filter(srcPath)) {
+            fs.mkdirSync(path.dirname(destPath), { recursive: true });
+            fs.copyFileSync(srcPath, destPath);
+        }
+    }
+}
 /**
  * Ensures the given directory exists, creating it if necessary.
  */

package/out/src/generator/emitters/prefab/prefabDepProvider.js

@@ -0,0 +1,104 @@
+/**
+ * Makes `@maxhealth.tech/prefab` resolvable while the generated output compiles.
+ *
+ * `--prefab` emits renderers that import the real prefab API, and the emitted
+ * package declares prefab as a dependency — but nothing puts it where the
+ * generator's own `tsc` pass can see it. Every emitted renderer then failed
+ * TS2307 and the whole package failed to compile, so a `--prefab` run produced
+ * no `prefab/` in the shipped package at all. It only ever passed when the
+ * output happened to sit inside a tree that already had prefab installed, which
+ * is why it looks fine from this repo's own `output/` and fails in CI.
+ *
+ * The real declarations are used rather than a stub. The emitted renderers are
+ * checked against prefab's actual component signatures, and their `.d.ts` quotes
+ * prefab's types back to the consumer — a hand-written stub would both drift
+ * from the library and erase those types from the emitted package.
+ *
+ * Two sources, in order: a copy already installed alongside the generator (this
+ * repo, where prefab is a devDependency), else a one-package install from the
+ * registry (an `npx babelfhir-ts` run, which ships no devDependencies). Only
+ * the declarations are copied — `tsc` reads no JavaScript — and whatever this
+ * added is removed after the compile, because the consumer installs the real
+ * dependency themselves.
+ */
+import fs from 'fs';
+import path from 'path';
+import { spawnSync } from 'child_process';
+import { fileURLToPath } from 'url';
+import { copyDirRecursive } from '../../core/utils.js';
+import { EMITTED_RANGES } from '../../core/generatedPackageDeps.js';
+import { logger } from '../../../logger.js';
+const log = logger.withTag('prefab');
+const PACKAGE_NAME = '@maxhealth.tech/prefab';
+const PACKAGE_SEGMENTS = PACKAGE_NAME.split('/');
+/** How far up a tree to look for a `node_modules` holding the package. */
+const MAX_LOOKUP_DEPTH = 8;
+/** The package directory under a given tree root, whether or not it exists. */
+function packageDirIn(root) {
+    return path.join(root, 'node_modules', ...PACKAGE_SEGMENTS);
+}
+/** Walk up from `start`, returning the first installed copy found. */
+function findInstalledCopy(start) {
+    let dir = start;
+    for (let i = 0; i < MAX_LOOKUP_DEPTH; i++) {
+        const candidate = packageDirIn(dir);
+        if (fs.existsSync(path.join(candidate, 'package.json')))
+            return candidate;
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return undefined;
+}
+/** Install the package into the output dir, declarations included. */
+function installFromRegistry(outputDir) {
+    const npm = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+    const spec = `${PACKAGE_NAME}@${EMITTED_RANGES.prefab}`;
+    log.debug(`Installing ${spec} for the output typecheck`);
+    const result = spawnSync(npm, ['install', '--no-save', '--no-package-lock', '--no-audit', '--no-fund',
+        '--prefix', outputDir, spec], { stdio: 'pipe', encoding: 'utf8' });
+    if (result.status !== 0) {
+        log.warn(`Could not install ${spec}: ${result.stderr?.trim() || `exit ${result.status}`}`);
+        return false;
+    }
+    return fs.existsSync(path.join(packageDirIn(outputDir), 'package.json'));
+}
+/**
+ * Ensure the emitted `prefab/` files can be typechecked from `outputDir`.
+ *
+ * @returns a cleanup that removes what this added, and does nothing when the
+ *          package was already resolvable.
+ */
+export function providePrefabTypes(outputDir) {
+    const alreadyResolvable = findInstalledCopy(outputDir);
+    if (alreadyResolvable) {
+        log.debug(`Typechecking prefab output against ${alreadyResolvable}`);
+        return () => { };
+    }
+    const target = packageDirIn(outputDir);
+    const generatorDir = path.dirname(fileURLToPath(import.meta.url));
+    const alongsideGenerator = findInstalledCopy(generatorDir);
+    if (alongsideGenerator) {
+        fs.mkdirSync(target, { recursive: true });
+        // Declarations only: `tsc` never reads the JavaScript, and prefab ships
+        // browser bundles and source maps that would triple the copy for nothing.
+        copyDirRecursive(alongsideGenerator, target, src => src.endsWith('.d.ts') || path.basename(src) === 'package.json');
+    }
+    else if (!installFromRegistry(outputDir)) {
+        throw new Error(`--prefab needs ${PACKAGE_NAME} to typecheck the emitted renderers, and it could not be ` +
+            `resolved next to the generator or installed from the registry. Install ` +
+            `${PACKAGE_NAME}@${EMITTED_RANGES.prefab} where generation runs, or drop --prefab.`);
+    }
+    return () => {
+        try {
+            fs.rmSync(target, { recursive: true, force: true });
+        }
+        catch { /* ignore */ }
+        // Leave `@maxhealth.tech/` behind only while it still holds something else.
+        try {
+            fs.rmdirSync(path.dirname(target));
+        }
+        catch { /* not empty — fine */ }
+    };
+}

package/out/src/generator/emitters/prefab/prefabEmitter.js

@@ -28,9 +28,9 @@ function ensurePrefabDir(outputDir) {
  * Emit `prefab/<InterfaceName>Prefab.ts` for a single profile.
  * Registers the profile so {@link finalizePrefabOutput} can build the barrel.
  */
-export function writePrefabProfile(outputDir, interfaceName, fields, resourceType) {
+export function writePrefabProfile(outputDir, interfaceName, fields, resourceType, valueSets) {
     const dir = ensurePrefabDir(outputDir);
-    const { code, fieldCount } = generatePrefabRenderer(interfaceName, fields, { resourceType });
+    const { code, fieldCount } = generatePrefabRenderer(interfaceName, fields, { resourceType, valueSets });
     const filePath = path.join(dir, `${interfaceName}Prefab.ts`);
     fs.writeFileSync(filePath, code);
     let map = emittedProfiles.get(outputDir);

package/out/src/generator/emitters/prefab/prefabRenderer.js

@@ -68,6 +68,17 @@ function emitToRowBody(descriptors) {
     const lines = descriptors.map(d => `    ${d.name}: ${rowAccessor(d)},`);
     return lines.join('\n');
 }
+/**
+ * Emit an `AutoFormOption[]` literal for a bound field.
+ *
+ * The label is omitted when the concept carried no display, because prefab
+ * already falls back to the value and restating it would only make the
+ * generated file longer.
+ */
+function emitOptionsLiteral(options) {
+    const entries = options.map(o => o.label ? `{ value: ${JSON.stringify(o.value)}, label: ${JSON.stringify(o.label)} }` : `{ value: ${JSON.stringify(o.value)} }`);
+    return `[${entries.join(', ')}]`;
+}
 /** Emit `autoForm` field descriptors. */
 function emitFormFields(descriptors) {
     const lines = [];
@@ -78,8 +89,12 @@ function emitFormFields(descriptors) {
         // Forms can't capture complex nested structures cleanly; skip them.
         if (d.kind === 'nested' || d.kind === 'json' || d.kind === 'image' || d.kind === 'dicom')
             continue;
-        if (d.isArray)
-            continue; // v1: scalars only
+        const options = d.enumOptions?.length ? d.enumOptions : undefined;
+        // A repeating element is only expressible as a form field when the choices
+        // are enumerated: prefab's multi-select submits a list under the name, which
+        // is the element's own shape. Any other array still has no control.
+        if (d.isArray && !options)
+            continue;
         let type = 'text';
         if (d.kind === 'number')
             type = 'number';
@@ -87,14 +102,15 @@ function emitFormFields(descriptors) {
             type = 'switch';
         else if (d.kind === 'date')
             type = 'date';
-        else if (d.enumValues && d.enumValues.length > 0)
+        else if (options)
             type = 'select';
         const extra = [`name: '${d.name}'`, `label: ${JSON.stringify(d.label)}`, `type: '${type}'`];
         if (d.required)
             extra.push('required: true');
-        // NOTE: @maxhealth.tech/prefab AutoFormField does not yet carry an `options`
-        // property for select inputs; the enum list is elided until the upstream
-        // type is widened. See prefab-ui#TODO.
+        if (options)
+            extra.push(`options: ${emitOptionsLiteral(options)}`);
+        if (d.isArray)
+            extra.push('multiple: true');
         lines.push(`    { ${extra.join(', ')} },`);
         seen.add(d.name);
     }
@@ -206,7 +222,7 @@ function emitBrowserTitleExpr(titleDescriptor, interfaceName) {
         : `selected.dot('${titleDescriptor.name}')`;
 }
 export function generatePrefabRenderer(interfaceName, fields, options) {
-    const rawDescriptors = fields.flatMap(describeField);
+    const rawDescriptors = fields.flatMap(f => describeField(f, options?.valueSets));
     const descriptors = dedupeDescriptors(rawDescriptors);
     const resourceType = options?.resourceType;
     const tableDescriptors = pickTableDescriptors(descriptors);

package/out/src/generator/emitters/prefab/prefabTypeMapper.js

@@ -8,6 +8,8 @@
  * This module is deliberately small and data-driven so it can later be
  * extracted into a shared codegen-spec package (see design notes).
  */
+import { lookupBoundValueSet } from '../requiredBindings.js';
+import { ctx } from '../../fhir/versionContext.js';
 /** Lower-cased FHIR primitive type codes. */
 const PRIMITIVE_TEXT = new Set([
     'string', 'code', 'uri', 'url', 'canonical', 'id', 'oid', 'uuid', 'markdown', 'xhtml',
@@ -23,6 +25,29 @@ function labelFor(name) {
     const spaced = name.replace(/([A-Z])/g, ' $1').replace(/[._-]/g, ' ').trim();
     return spaced.charAt(0).toUpperCase() + spaced.slice(1);
 }
+/**
+ * Build the choice list for a bound field, or undefined when there is none to
+ * offer.
+ *
+ * The parsed ValueSet is preferred over the codes the SD parser sampled onto
+ * the binding: it carries the concept displays, and it is the whole set rather
+ * than a subset. Both paths are capped at the same `STORE_CODES` threshold the
+ * parser and the interface emitter already use to decide a ValueSet is small
+ * enough to enumerate — past it a Select stops being a usable control and the
+ * field stays a free-text input.
+ */
+function selectOptionsFor(field, valueSets) {
+    const limit = ctx().valueSetThresholds.STORE_CODES;
+    const resolved = lookupBoundValueSet(field.binding?.uri, valueSets);
+    const concepts = resolved?.valueSet.concepts;
+    if (concepts?.length && concepts.length <= limit) {
+        return concepts.map(c => ({ value: c.code, ...(c.display ? { label: c.display } : {}) }));
+    }
+    const sampled = field.binding?.codes?.filter(c => c.code).map(c => ({ value: c.code }));
+    if (sampled?.length && sampled.length <= limit)
+        return sampled;
+    return undefined;
+}
 function kindForType(fhirType) {
     if (PRIMITIVE_TEXT.has(fhirType))
         return 'text';
@@ -86,7 +111,7 @@ function kindForType(fhirType) {
  * on the typed interface. Detail views for nested backbone elements are a
  * follow-up once slicing-aware tree rendering lands.
  */
-export function describeField(field) {
+export function describeField(field, valueSets) {
     if (field.isForbidden)
         return [];
     if (!field.type)
@@ -132,7 +157,7 @@ export function describeField(field) {
                 label: labelFor(variantPropName),
                 valueSetUri: field.binding?.uri,
                 bindingStrength: field.binding?.strength,
-                enumValues: field.binding?.codes?.map(c => c.code).filter(Boolean),
+                enumOptions: selectOptionsFor(field, valueSets),
             });
         }
         return out;
@@ -158,7 +183,7 @@ export function describeField(field) {
             label: labelFor(bareName),
             valueSetUri: field.binding?.uri,
             bindingStrength: field.binding?.strength,
-            enumValues: field.binding?.codes?.map(c => c.code).filter(Boolean),
+            enumOptions: selectOptionsFor(field, valueSets),
         }];
 }
 /**

package/out/src/generator/emitters/requiredBindings.js

@@ -21,17 +21,31 @@ import { stripVersionFromCanonicalUrl } from '../core/utils.js';
 import { sanitizeValueSetName } from './valueset/valueSetGenerator.js';
 /** Types FHIR permits a binding on. */
 const BINDABLE_TYPES = ['code', 'Coding', 'CodeableConcept', 'Quantity', 'string', 'uri'];
-export function resolveRequiredBindingValueSet(bindingUri, valueSets) {
+/**
+ * Resolve a binding URI to its parsed ValueSet, versioned key first.
+ *
+ * A binding may cite `…/ValueSet/foo|1.0.0` while the package indexes the
+ * ValueSet under its unversioned canonical, so both keys have to be tried.
+ * Every emitter that reads concepts off a binding needs the same two lookups,
+ * which is why it lives here rather than in each of them.
+ */
+export function lookupBoundValueSet(bindingUri, valueSets) {
     if (!bindingUri || !valueSets)
         return undefined;
-    let vs = valueSets.get(bindingUri);
-    let resolvedUri = bindingUri;
-    if (!vs && bindingUri.includes('|')) {
-        resolvedUri = stripVersionFromCanonicalUrl(bindingUri);
-        vs = valueSets.get(resolvedUri);
-    }
-    if (!vs)
+    const direct = valueSets.get(bindingUri);
+    if (direct)
+        return { valueSet: direct, resolvedUri: bindingUri };
+    if (!bindingUri.includes('|'))
+        return undefined;
+    const strippedUri = stripVersionFromCanonicalUrl(bindingUri);
+    const stripped = valueSets.get(strippedUri);
+    return stripped ? { valueSet: stripped, resolvedUri: strippedUri } : undefined;
+}
+export function resolveRequiredBindingValueSet(bindingUri, valueSets) {
+    const resolved = lookupBoundValueSet(bindingUri, valueSets);
+    if (!resolved || !bindingUri)
         return undefined;
+    const { valueSet: vs, resolvedUri } = resolved;
     const displayName = resolvedUri.split('/').pop() || vs.name;
     if (vs.concepts.length === 0) {
         if (vs.systems && vs.systems.length > 0) {

package/out/src/generator/emitters/zod/zodStubInstaller.js

@@ -12,6 +12,7 @@ import path from 'path';
 import { fileURLToPath } from 'url';
 import { versionSlug } from '../../fhir/versionContext.js';
 import { getZodPackageTypes } from './zodTypes.js';
+import { copyDirRecursive } from '../../core/utils.js';
 /** Resolve the repo root from this file's location (src/generator/emitters/zod/) */
 function findRepoRoot() {
     const selfDir = path.dirname(fileURLToPath(import.meta.url));
@@ -26,20 +27,6 @@ function findRepoRoot() {
     }
     return path.resolve(selfDir, '..', '..', '..', '..');
 }
-/** Recursively copy a directory's contents, handling nested subdirectories. */
-function copyDirRecursive(src, dest) {
-    for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
-        const srcPath = path.join(src, entry.name);
-        const destPath = path.join(dest, entry.name);
-        if (entry.isDirectory()) {
-            fs.mkdirSync(destPath, { recursive: true });
-            copyDirRecursive(srcPath, destPath);
-        }
-        else {
-            fs.copyFileSync(srcPath, destPath);
-        }
-    }
-}
 export function installBaseZodTypes(outputDir) {
     const slug = versionSlug();
     const pkgDir = path.join(outputDir, 'node_modules', '@babelfhir-ts', 'zod');

package/out/src/generator/index.js

@@ -619,10 +619,19 @@ export async function generateIntoPackage(packageArchivePath, outArchivePath, fl
         // Install fhirpath type stub so tsc can resolve validator imports
         const { installFhirpathStub, removeFhirpathStub } = await import('./emitters/validator/fhirpathStubInstaller.js');
         installFhirpathStub(outputDir);
+        // Emitted renderers import the real prefab API, which nothing has installed here yet
+        const releasePrefabTypes = flags?.prefab
+            ? (await import('./emitters/prefab/prefabDepProvider.js')).providePrefabTypes(outputDir)
+            : undefined;
         // Compile TypeScript to JavaScript
         endPhase = startPhase('compile');
         logger.log('Compiling TypeScript to JavaScript...');
-        await compileTypeScriptToJS(outputDir);
+        try {
+            await compileTypeScriptToJS(outputDir);
+        }
+        finally {
+            releasePrefabTypes?.();
+        }
         endPhase(); // compile
         // Remove fhirpath stub — the real package is a peer dependency
         removeFhirpathStub(outputDir);
@@ -841,9 +850,17 @@ export async function generateIntoPackageDirect(packageArchivePath, flags) {
     }
     const { installFhirpathStub, removeFhirpathStub } = await import('./emitters/validator/fhirpathStubInstaller.js');
     installFhirpathStub(outputDir);
+    const releasePrefabTypes = flags?.prefab
+        ? (await import('./emitters/prefab/prefabDepProvider.js')).providePrefabTypes(outputDir)
+        : undefined;
     endPhase = startPhase('compile');
     logger.log('Compiling TypeScript to JavaScript...');
-    await compileTypeScriptToJS(outputDir);
+    try {
+        await compileTypeScriptToJS(outputDir);
+    }
+    finally {
+        releasePrefabTypes?.();
+    }
     endPhase(); // compile
     removeFhirpathStub(outputDir);
     const babelfhirDir = path.join(outputDir, 'node_modules', '@babelfhir-ts');

package/out/src/generator/sdProcessor.js

@@ -750,7 +750,7 @@ export async function processStructureDefinition(sd, ctx) {
     }
     if (flags?.prefab) {
         const { writePrefabProfile } = await import('./emitters/prefab/prefabEmitter.js');
-        writePrefabProfile(outputDir, interfaceName, aligned.alignedNewFields, sd.type);
+        writePrefabProfile(outputDir, interfaceName, aligned.alignedNewFields, sd.type, valueSets);
     }
     logger.log(`Generated artifacts for ${interfaceName}`);
     return interfaceName;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "babelfhir-ts",
-  "version": "1.6.8",
+  "version": "1.6.10",
   "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",
@@ -87,7 +87,7 @@
   "devDependencies": {
     "@eslint/js": "^10.0.1",
     "@max-health-inc/config": "^3.1.0",
-    "@maxhealth.tech/prefab": "^0.3.7",
+    "@maxhealth.tech/prefab": "^0.3.12",
     "@types/node": "^25.9.5",
     "@types/semver": "^7.8.0",
     "@types/unzipper": "^0.10.11",