babelfhir-ts 1.5.4 → 1.5.5

package/out/src/generator/emitters/interface/backboneSliceTyping.js

@@ -70,7 +70,7 @@ export function generateBackboneSliceTypes(ctx) {
                 return childId.startsWith(sliceElementId + '.');
             });
             // Build interface body lines from slice children and the slice's own constraints
-            const { lines: bodyLines, referencedFhirTypes } = buildSliceInterfaceBody(sliceField, sliceChildren, sliceElementId, backboneType);
+            const { lines: bodyLines, referencedFhirTypes } = buildSliceInterfaceBody(sliceField, sliceChildren, sliceElementId, backboneType, baseFields, parentField.name);
             if (bodyLines.length === 0) {
                 // No constrainable properties — skip this slice interface
                 log.debug(`No constraints for slice ${sliceName} of ${parentField.name}, skipping`);
@@ -197,7 +197,7 @@ function gatherChildFields(fields, path) {
 /**
  * Build the body lines for a slice-specific interface.
  */
-function buildSliceInterfaceBody(sliceField, sliceChildren, sliceElementId, _backboneType) {
+function buildSliceInterfaceBody(sliceField, sliceChildren, sliceElementId, _backboneType, baseFields, parentPath) {
     const lines = [];
     const referencedFhirTypes = [];
     // Add pattern constraint from the slice field itself (discriminator value)
@@ -211,16 +211,58 @@ function buildSliceInterfaceBody(sliceField, sliceChildren, sliceElementId, _bac
             }
         }
     }
-    // Process direct children of the slice
+    // Pre-scan: identify choice-type parent elements (value[x]) that have
+    // sub-slices (value[x]:valueQuantity, etc.). These parents carry only slicing
+    // metadata and should not be emitted as typed properties.
+    // Match only direct choice-type slices like "value[x]:valueString" — NOT deeper
+    // elements like "value[x].extension:questionnaireDisplay" where the colon is
+    // on a different segment.
+    const choiceTypeParents = new Set();
+    const choiceTypeSlices = [];
+    const choiceSlicePattern = /^([^.]+\[x]):([^.]+)$/; // e.g. "value[x]:valueString"
     for (const child of sliceChildren) {
         const childId = child.elementId || child.name;
         const relativePath = childId.substring(sliceElementId.length + 1);
-        // Only handle direct children (no dots in relative path)
-        if (relativePath.includes('.'))
+        const match = choiceSlicePattern.exec(relativePath);
+        if (match) {
+            choiceTypeSlices.push(child);
+            choiceTypeParents.add(match[1]); // e.g. "value[x]"
+        }
+    }
+    // Collect deeply nested fixed values for object literal synthesis.
+    // e.g. code.coding.code = "confidence" → code: { coding: [{ code: "confidence" }] }
+    const nestedFixedByProp = new Map();
+    // Process children of the slice
+    for (const child of sliceChildren) {
+        const childId = child.elementId || child.name;
+        const relativePath = childId.substring(sliceElementId.length + 1);
+        // Nested children (dots in relative path) — collect fixed values for synthesis
+        if (relativePath.includes('.')) {
+            if (child.fixedValue !== undefined) {
+                const segments = relativePath.split('.');
+                const rawPropName = segments[0];
+                const propName = rawPropName.replace(/\[x\]$/, '');
+                // Skip nested values under:
+                // - choice-type elements ([x]) — handled by direct child or sub-slices
+                // - slice notation (part:LineItem.name) — deeper-level constraints
+                // - extension/modifierExtension — handled by postProcessExtensions
+                if (!rawPropName.includes('[x]') && !rawPropName.includes(':')
+                    && propName !== 'extension' && propName !== 'modifierExtension') {
+                    const nestedPath = segments.slice(1).join('.');
+                    if (!nestedFixedByProp.has(propName))
+                        nestedFixedByProp.set(propName, new Map());
+                    nestedFixedByProp.get(propName).set(nestedPath, String(child.fixedValue));
+                }
+            }
             continue;
-        // Skip slice notation in child paths
+        }
+        // Choice-type sub-slices (value[x]:valueXxx) are processed separately below
         if (relativePath.includes(':'))
             continue;
+        // Skip choice-type parents that have sub-slices — they carry only slicing
+        // metadata and their inherited type (e.g. Quantity) is misleading
+        if (choiceTypeParents.has(relativePath))
+            continue;
         const propName = relativePath.replace(/\[x\]$/, '');
         if (child.fixedValue !== undefined) {
             // Fixed value constraint
@@ -270,6 +312,43 @@ function buildSliceInterfaceBody(sliceField, sliceChildren, sliceElementId, _bac
             }
         }
     }
+    // Emit choice-type sub-slice properties (e.g. value[x]:valueQuantity → valueQuantity: Quantity)
+    for (const child of choiceTypeSlices) {
+        if (!child.sliceName || !child.type)
+            continue;
+        if (child.type === 'BackboneElement' || child.type === 'Element' || child.type === 'any')
+            continue;
+        const rawType = getRules().mapTypeToTS(child.type);
+        const mappedType = sanitizeIdentifier(rawType);
+        if (mappedType !== rawType && child.isProfiled)
+            continue;
+        const optMark = child.isOptional ? '?' : '';
+        lines.push(`${child.sliceName}${optMark}: ${mappedType};`);
+        if (getRules().isFhirType(mappedType)) {
+            referencedFhirTypes.push(mappedType);
+        }
+    }
+    // Emit synthesized nested object literals from deeply nested fixed values.
+    // Skip properties already emitted by the direct child or choice-type loops
+    // to prevent TS2717 (duplicate property) and TS2430 (incompatible extends).
+    const emittedProps = new Set(lines.map(l => l.match(/^(\w+)[?]?:/)?.[1]).filter(Boolean));
+    for (const [propName, paths] of nestedFixedByProp) {
+        if (emittedProps.has(propName))
+            continue;
+        // Check if this property is an array — look in both slice children and
+        // base fields. Synthesized literals for array properties need wrapping
+        // in [] to avoid TS2430 (incompatible extends).
+        const propFullPath = `${parentPath}.${propName}`;
+        const isArrayProp = sliceChildren.some(c => {
+            const cId = c.elementId || c.name;
+            const rel = cId.substring(sliceElementId.length + 1);
+            return rel === propName && c.isArray;
+        }) || baseFields.some(f => f.name === propFullPath && f.isArray);
+        const literal = synthesizeNestedLiteral(paths);
+        if (literal) {
+            lines.push(`${propName}: ${isArrayProp ? `[${literal}]` : literal};`);
+        }
+    }
     return { lines, referencedFhirTypes };
 }
 /**
@@ -294,6 +373,39 @@ function formatCodingLiteral(codings) {
         return null;
     return `[${entries.join(', ')}]`;
 }
+/**
+ * Synthesize a nested object literal from deeply nested fixed values.
+ *
+ * Given a map of nested paths → values (e.g. { "coding.code" → "confidence" }),
+ * produces an object literal like `{ coding: [{ code: "confidence" }] }`.
+ *
+ * Special handling: `coding` segments are wrapped in array brackets because
+ * `CodeableConcept.coding` is always an array in FHIR.
+ */
+function synthesizeNestedLiteral(paths) {
+    const codingFields = new Map();
+    const scalarFields = [];
+    for (const [path, value] of paths) {
+        if (path.startsWith('coding.')) {
+            codingFields.set(path.substring('coding.'.length), value);
+        }
+        else if (!path.includes('.')) {
+            scalarFields.push([path, value]);
+        }
+        // Deeper nesting (3+ levels) is uncommon; skip gracefully
+    }
+    const parts = [];
+    if (codingFields.size > 0) {
+        const codingParts = [...codingFields.entries()].map(([k, v]) => `${k}: "${v}"`);
+        parts.push(`coding: [{ ${codingParts.join('; ')} }]`);
+    }
+    for (const [field, value] of scalarFields) {
+        parts.push(`${field}: "${value}"`);
+    }
+    if (parts.length === 0)
+        return null;
+    return `{ ${parts.join('; ')} }`;
+}
 /**
  * Update the root interface to use the union type for a sliced backbone field.
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "babelfhir-ts",
-  "version": "1.5.4",
+  "version": "1.5.5",
   "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",