babelfhir-ts 1.5.3 → 1.5.4

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

@@ -30,7 +30,7 @@ export function generateBackboneSliceTypes(ctx) {
     const { interfaceName, baseResource, newFields, baseFields, interfaces, importManager, inferBackboneType } = ctx;
     const rules = getRules();
     // 1. Find all sliced backbone element arrays
-    const sliceGroups = collectSliceGroups(newFields, baseResource);
+    const sliceGroups = collectSliceGroups(newFields, baseFields, baseResource);
     if (sliceGroups.length === 0)
         return;
     for (const group of sliceGroups) {
@@ -109,10 +109,18 @@ export function generateBackboneSliceTypes(ctx) {
 }
 /**
  * Collect sliced backbone element groups from the fields.
+ *
+ * Handles two scenarios:
+ * 1. The differential includes the unsliced parent field (e.g. Observation.component) —
+ *    the parent field carries slicing metadata and baseTypeCode.
+ * 2. The differential only contains slice entries (e.g. Observation.component:confidence)
+ *    without redeclaring the parent — common in downstream profiles. In this case the
+ *    parent field is looked up from baseFields.
  */
-function collectSliceGroups(fields, baseResource) {
+function collectSliceGroups(fields, baseFields, baseResource) {
     const groups = [];
     const seenPaths = new Set();
+    // Pass 1: parent field present in newFields
     for (const field of fields) {
         if (field.sliceName)
             continue; // Skip slice entries themselves
@@ -121,48 +129,71 @@ function collectSliceGroups(fields, baseResource) {
         const path = field.name;
         if (seenPaths.has(path))
             continue;
-        // Check if there are named slices at this path
         const sliceFields = fields.filter(f => f.name === path && f.sliceName);
         if (sliceFields.length === 0)
             continue;
-        // Must be a true backbone element — only process fields whose base FHIR type
-        // is BackboneElement or Element (inline nested types). Skip complex DataTypes
-        // like Identifier, CodeableConcept, ContactPoint, etc. — those have slices
-        // handled by the main type mapping and profiled type reference system.
-        const baseType = field.baseTypeCode || field.type || '';
-        if (baseType !== 'BackboneElement' && baseType !== 'Element')
+        if (!isEligibleBackbonePath(field.baseTypeCode || field.type || '', path, baseResource))
+            continue;
+        const childFields = gatherChildFields(fields, path);
+        const slicingRules = field.slicingRules || 'open';
+        seenPaths.add(path);
+        groups.push({ parentField: field, sliceFields, childFields, slicingRules });
+    }
+    // Pass 2: orphaned slice entries whose parent path wasn't found in newFields.
+    // The differential may only contain slice entries (e.g. Observation.component:confidence)
+    // without the unsliced parent. Resolve the parent from baseFields.
+    for (const field of fields) {
+        if (!field.sliceName)
+            continue;
+        const path = field.name;
+        if (seenPaths.has(path))
             continue;
-        // Skip extension slices — handled separately by postProcessExtensions
-        const fieldName = path.split('.').pop() || '';
-        if (fieldName === 'extension' || fieldName === 'modifierExtension')
+        // Find the parent field in baseFields
+        const parentField = baseFields.find(f => f.name === path && !f.sliceName);
+        if (!parentField)
             continue;
-        // Skip Bundle.entry and similar resource-container slices — these use profiled
-        // type references that are handled by the external profile resolution system
-        if (fieldName === 'entry')
+        if (!parentField.isArray)
             continue;
-        // Must be a root-level field (direct child of the base resource)
-        const parts = path.split('.');
-        if (parts.length !== 2)
+        if (!isEligibleBackbonePath(parentField.baseTypeCode || parentField.type || '', path, baseResource))
             continue;
-        if (baseResource && parts[0] !== baseResource)
+        const sliceFields = fields.filter(f => f.name === path && f.sliceName);
+        if (sliceFields.length === 0)
             continue;
-        // Gather all child fields for any slice of this element
-        const childFields = fields.filter(f => {
-            if (f.name === path)
-                return false; // Skip the parent itself
-            const childId = f.elementId || f.name;
-            // Match children that belong to ANY slice of this element
-            return childId.startsWith(`${path}:`) || (f.name.startsWith(`${path}.`) && f.name !== path);
-        });
-        // Determine slicing rules from the parent field's metadata
-        // The slicing rules come from the SD's element.slicing.rules
-        // We default to 'open' since that's the FHIR default
-        const slicingRules = field.slicingRules || 'open';
+        const childFields = gatherChildFields(fields, path);
+        const slicingRules = parentField.slicingRules || 'open';
         seenPaths.add(path);
-        groups.push({ parentField: field, sliceFields, childFields, slicingRules });
+        groups.push({ parentField, sliceFields, childFields, slicingRules });
     }
     return groups;
 }
+/** Check whether a field path is eligible for backbone slice typing. */
+function isEligibleBackbonePath(baseType, path, baseResource) {
+    if (baseType !== 'BackboneElement' && baseType !== 'Element')
+        return false;
+    const fieldName = path.split('.').pop() || '';
+    // Skip extension slices — handled separately by postProcessExtensions
+    if (fieldName === 'extension' || fieldName === 'modifierExtension')
+        return false;
+    // Skip Bundle.entry and similar resource-container slices
+    if (fieldName === 'entry')
+        return false;
+    // Must be a root-level field (direct child of the base resource)
+    const parts = path.split('.');
+    if (parts.length !== 2)
+        return false;
+    if (baseResource && parts[0] !== baseResource)
+        return false;
+    return true;
+}
+/** Gather all child fields for any slice of the given parent path. */
+function gatherChildFields(fields, path) {
+    return fields.filter(f => {
+        if (f.name === path)
+            return false;
+        const childId = f.elementId || f.name;
+        return childId.startsWith(`${path}:`) || (f.name.startsWith(`${path}.`) && f.name !== path);
+    });
+}
 /**
  * Build the body lines for a slice-specific interface.
  */

package/package.json

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