babelfhir-ts 1.5.19 → 1.5.20

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

@@ -57,6 +57,25 @@ export const FETCH_TIMEOUT_MS = 15_000;
 export const TX_TIMEOUT_MS = 30_000;
 /** Max filename length for terminology expansion cache files */
 export const MAX_CACHE_FILENAME_LENGTH = 200;
+/**
+ * FHIR package registries in priority order.
+ *
+ * packages.fhir.org is the canonical source; packages.simplifier.net is the
+ * fallback and carries some national IGs the canonical registry does not mirror.
+ * Both speak the npm metadata shape, so `GET <registry>/<packageId>` returns
+ * `dist-tags` and `versions`.
+ */
+/**
+ * Attempts per registry when downloading a package tarball.
+ *
+ * Registry blips are the single largest cause of spurious parity failures: a run
+ * pulls ~30 packages and a lone `fetch failed` aborted the whole generation.
+ */
+export const PACKAGE_DOWNLOAD_ATTEMPTS = 3;
+export const FHIR_REGISTRIES = [
+    'https://packages.fhir.org',
+    'https://packages.simplifier.net',
+];
 // ─── FHIR StructureDefinition URL prefixes ───────────────────────────────────
 export const FHIR_SD_URL_PREFIX = 'http://hl7.org/fhir/StructureDefinition/';
 export const FHIR_SD_URL_PREFIX_HTTPS = 'https://hl7.org/fhir/StructureDefinition/';

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

@@ -24,6 +24,38 @@ export function capitalize(str) {
         return str;
     return str.charAt(0).toUpperCase() + str.slice(1);
 }
+/**
+ * The property name a choice element takes for one of its permitted types.
+ *
+ * A choice element has no property of its own: FHIR declares one property per
+ * permitted type, named for the type code capitalized (`value[x]` as a
+ * SampledData is `valueSampledData`, as a `code` primitive it is `valueCode`).
+ *
+ * Pass the *type code*, never a profile name. R4 declares
+ * `Coverage.costToBeneficiary.value[x]` as a Quantity profiled to SimpleQuantity,
+ * and the property is `valueQuantity` — `valueSimpleQuantity` does not exist on
+ * any resource, so emitting it produces data every validator rejects.
+ *
+ * @param baseName the choice element's name with `[x]` already removed
+ */
+export function choicePropertyName(baseName, typeCode) {
+    return baseName + capitalize(typeCode);
+}
+/**
+ * The single type a choice element has been narrowed to, or undefined while it
+ * still permits more than one.
+ *
+ * A still-open choice has no one property name, so callers must leave the base
+ * definition's expanded properties in force rather than pick a type.
+ */
+export function narrowedChoiceType(field) {
+    if (field.typeOptions && field.typeOptions.length > 1)
+        return undefined;
+    const type = field.typeOptions?.[0]?.code || field.type;
+    if (!type || type === 'any' || type === 'unknown')
+        return undefined;
+    return type;
+}
 /**
  * Extract base FHIR types from all interface declarations in a file.
  * Handles:
@@ -220,9 +252,16 @@ function caseAwareWriteFile(filePath, content) {
 }
 /**
  * Extracts the base resource name from a baseDefinition URL.
+ *
+ * The version suffix has to go first. A canonical may be pinned
+ * (`http://hl7.org/fhir/StructureDefinition/Base|4.0.1`, as IPS 2.0.1's logical
+ * models write it), and keeping it yielded the base name `Base_4_0_1` after
+ * sanitising. That defeated the `baseResource === 'Base'` check that suppresses
+ * extending the abstract root, so the emitter produced
+ * `export type Document = Base_4_0_1` plus an import of a type nothing generates.
  */
 export function getBaseResource(baseDefinition) {
-    return baseDefinition?.split("/").pop() || "Resource";
+    return stripVersionFromCanonicalUrl(baseDefinition ?? '').split('/').pop() || 'Resource';
 }
 /**
  * Sanitizes a string so it can be used as a valid TypeScript identifier.

package/out/src/generator/emitters/class/sliceElementDefaults.js

@@ -221,7 +221,9 @@ export function buildNestedRequirementsObject(nestedRequirements) {
     if (!nestedRequirements || nestedRequirements.length === 0) {
         return null;
     }
-    // Collect all array segments from all requirements to know which paths need array wrapping
+    // Relative paths that are arrays, so nesting knows where to wrap. Keyed by the
+    // full relative path rather than by segment name: `name.part` is 0..* while the
+    // `part` string inside it is 1..1, and one shared verdict wrapped the string too.
     const allArraySegments = new Set();
     for (const req of nestedRequirements) {
         if (req.arraySegments) {
@@ -250,7 +252,7 @@ export function buildNestedRequirementsObject(nestedRequirements) {
         // Navigate/create nested objects for all but the last part
         for (let i = 0; i < parts.length - 1; i++) {
             const part = parts[i];
-            const isArraySegment = allArraySegments.has(part);
+            const isArraySegment = allArraySegments.has(parts.slice(0, i + 1).join('.'));
             if (!(part in current)) {
                 // Create either an array with one object or a plain object
                 if (isArraySegment) {
@@ -346,7 +348,7 @@ export function buildNestedRequirementsObject(nestedRequirements) {
         }
         // If the final segment is an array segment, wrap the value in an array.
         // Also wrap if the field is inherently an array in FHIR base types
-        const shouldWrap = (allArraySegments.has(lastPart) || FHIR_BASE_ARRAY_FIELDS.has(lastPart))
+        const shouldWrap = (allArraySegments.has(req.path) || FHIR_BASE_ARRAY_FIELDS.has(lastPart))
             && !Array.isArray(value);
         if (shouldWrap) {
             current[lastPart] = [value];

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

@@ -18,7 +18,7 @@
  * }
  * ```
  */
-import { capitalize, sanitizeIdentifier } from '../../core/utils.js';
+import { capitalize, choicePropertyName, narrowedChoiceType, sanitizeIdentifier } from '../../core/utils.js';
 import { getRules } from '../../fhir/versionContext.js';
 import { logger } from '../../../logger.js';
 const log = logger.withTag('backbone-slices');
@@ -263,7 +263,18 @@ function buildSliceInterfaceBody(sliceField, sliceChildren, sliceElementId, _bac
         // metadata and their inherited type (e.g. Quantity) is misleading
         if (choiceTypeParents.has(relativePath))
             continue;
-        const propName = relativePath.replace(/\[x\]$/, '');
+        // A choice element has no property of its own, so it is named for the single
+        // type the slice narrowed it to. Stripping `[x]` produced `value`, `effective`
+        // and the like — properties no resource carries, so the slice demanded a
+        // property FHIR has no such thing as while leaving the real `valueSampledData`
+        // unconstrained. A choice still open here names nothing and is skipped.
+        let propName = relativePath;
+        if (propName.endsWith('[x]')) {
+            const narrowedTo = narrowedChoiceType(child);
+            if (!narrowedTo)
+                continue;
+            propName = choicePropertyName(propName.slice(0, -'[x]'.length), narrowedTo);
+        }
         if (child.fixedValue !== undefined) {
             // Fixed value constraint
             const fixedLiteral = JSON.stringify(child.fixedValue);

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

@@ -191,6 +191,33 @@ export class ImportManager {
         }
         return statements.join('\n');
     }
+    /**
+     * Whether `name` is referenced in `body`, counting the profile ids that
+     * resolve to it as references too.
+     *
+     * An external profile can be reached under more than one name: the id taken
+     * from its canonical URL (`AuDosage` from `.../au-dosage`) and the interface
+     * name it is finally generated under (`AUBaseDosage`, from the SD's name).
+     * `generateImportStatements` deduplicates those to the resolved name, but the
+     * interface body is still written with the id at that point — a later pass
+     * rewrites it. Matching only the resolved name therefore pruned an import that
+     * the rewritten body goes on to need, leaving a dangling reference (TS2304 on
+     * `AUBaseDosage` in au-core 2.0.0's AUCoreMedicationStatement, and the same
+     * shape in davinci-pas and davinci-dtr).
+     */
+    isReferencedAllowingAliases(name, body) {
+        if (new RegExp(`\\b${name}\\b`).test(body))
+            return true;
+        if (!this.profileIdToName)
+            return false;
+        for (const [alias, resolved] of this.profileIdToName) {
+            if (resolved !== name || alias === name)
+                continue;
+            if (new RegExp(`\\b${alias}\\b`).test(body))
+                return true;
+        }
+        return false;
+    }
     /**
      * Prunes unused imports from generated code.
      * Removes import statements for types that aren't actually used.
@@ -213,8 +240,7 @@ export class ImportManager {
             const used = [];
             const specifiers = inside.split(',').map((s) => s.trim()).filter(Boolean);
             for (const name of specifiers) {
-                const re = new RegExp(`\\b${name}\\b`);
-                if (re.test(output.replace(full, ''))) {
+                if (this.isReferencedAllowingAliases(name, output.replace(full, ''))) {
                     used.push(name);
                 }
             }

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

@@ -1,4 +1,4 @@
-import { capitalize, sanitizeIdentifier, toPascalCase, stripVersionFromCanonicalUrl } from '../../core/utils.js';
+import { capitalize, choicePropertyName, narrowedChoiceType, sanitizeIdentifier, toPascalCase, stripVersionFromCanonicalUrl } from '../../core/utils.js';
 import { sanitizeValueSetName } from '../valueset/valueSetGenerator.js';
 import { logger } from '../../../logger.js';
 import { getRules } from '../../fhir/versionContext.js';
@@ -214,25 +214,30 @@ export function processFields(ctx, fields, parentInterfaceName, parentFieldType,
             });
             return;
         }
-        if (fieldName === "value[x]")
-            fieldName = "value";
-        if (fieldName === "event[x]" && field.type === "any" && field.fixedValue === undefined)
-            return;
-        if (fieldName === "event[x]")
-            fieldName = "event";
-        if (fieldName === "deceased[x]")
-            fieldName = "deceased";
+        // `extension[x]` is a parser artifact rather than a FHIR choice — Extension.extension
+        // is a plain repeating element — so it keeps its name.
         if (fieldName === "extension[x]")
             fieldName = "extension";
-        if (fieldName === "multipleBirth[x]")
-            fieldName = "multipleBirth";
         // Helper to retrieve original last segment before local renaming
         function fieldNameOriginal(fullName) { return fullName.split('.').pop() || fullName; }
-        // Generic handling: for choice elements (ending in [x]) that we do NOT explicitly map above,
-        // we skip emitting them so the base resource's expanded choice properties remain intact (e.g., onsetDateTime, onsetAge,...).
-        if (/\[x\]$/.test(fieldNameOriginal(field.name)) && !['value[x]', 'event[x]', 'deceased[x]', 'extension[x]', 'multipleBirth[x]'].includes(fieldNameOriginal(field.name))) {
-            debug('skip choice element to inherit base choice fields', field.name);
-            return;
+        // Choice elements carry no property of their own: FHIR declares one property
+        // per permitted type. A profile that narrows the choice to a single type names
+        // that property, so the constraint lands on the property the resource actually
+        // carries; anything still open is skipped, leaving the base definition's
+        // expanded choice properties in force (onsetDateTime, onsetAge, …).
+        //
+        // value[x], event[x], deceased[x] and multipleBirth[x] used to be renamed to
+        // value/event/deceased/multipleBirth, none of which exist on any resource.
+        // A slice narrowing Observation.component.value[x] to SampledData declared
+        // `value: SampledData`, so a caller writing correct FHIR failed to typecheck
+        // for a missing `value` while `valueSampledData` went unconstrained.
+        if (/\[x\]$/.test(fieldNameOriginal(field.name))) {
+            const narrowedTo = narrowedChoiceType(field);
+            if (!narrowedTo) {
+                debug('skip choice element to inherit base choice fields', field.name);
+                return;
+            }
+            fieldName = choicePropertyName(fieldName.replace(/\[x\]$/, ''), narrowedTo);
         }
         if (isFhirType(capitalize(fieldName)) && field.type === "any" && field.fixedValue === undefined && !(fieldName === 'extension' && hasSamePathExtensionSlices)) {
             if (isAaaCodesContext)

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

@@ -13,6 +13,22 @@ export function canonicalToTypeName(name, profileUrlToName) {
         }
         t = t.split('/').pop() || t;
     }
+    // A bare profile id also has a registered interface name, and it is not
+    // derivable from the id: davinci-pas 2.2.1's `profile-identifier` is generated
+    // as `PASIdentifier` (from the SD's `name`), so PascalCasing the id produced
+    // `ProfileIdentifier` — a type that is referenced and imported but never
+    // emitted (TS2307/TS2304 across seven files). Resolve through the registry by
+    // matching the URL's last segment, and only when it is unambiguous.
+    if (profileUrlToName && !/^https?:\/\//.test(t)) {
+        const matches = new Set();
+        for (const [url, generatedName] of profileUrlToName) {
+            if ((url.split('/').pop() || '').toLowerCase() === t.toLowerCase()) {
+                matches.add(generatedName);
+            }
+        }
+        if (matches.size === 1)
+            return [...matches][0];
+    }
     // if already a valid identifier with capitalization, return as-is
     if (/^[A-Za-z_][A-Za-z0-9_]*$/.test(t) && /[A-Z]/.test(t[0]))
         return t;