gdc-common-utils-ts 2.0.6 → 2.0.8

package/dist/utils/clinical-resource-view.d.ts

@@ -29,6 +29,28 @@ export type ClinicalResourceExpandedView = Readonly<{
     xhtml?: string;
     notes: string[];
 }>;
+export type ClinicalResourceLike = Readonly<{
+    resourceType?: string;
+    text?: {
+        div?: unknown;
+    };
+    meta?: {
+        claims?: Record<string, unknown>;
+    };
+    note?: unknown;
+    code?: unknown;
+    valueQuantity?: unknown;
+    [key: string]: unknown;
+}>;
+export type LocalTextAndIntDisplay = Readonly<{
+    localText?: string;
+    internationalDisplay?: string;
+    combined?: string;
+}>;
+export type NarrativeResult = Readonly<{
+    xhtml?: string;
+    source: 'resource.text.div' | 'derived-from-claims' | 'missing';
+}>;
 export type ClinicalResourceEntryLike = Readonly<{
     fullUrl?: string;
     type?: string;
@@ -65,3 +87,18 @@ export declare function toClinicalResourceExpandedView(entry: ClinicalResourceEn
  * Maps all entries from a Bundle into expanded views.
  */
 export declare function toClinicalResourceExpandedViews(bundle: ClinicalResourceBundleLike): ClinicalResourceExpandedView[];
+/**
+ * Returns the most useful local text plus international display pair that can
+ * be inferred from one FHIR-like resource and its `meta.claims`.
+ */
+export declare function getLocalTextAndIntDisplay(resource: ClinicalResourceLike): LocalTextAndIntDisplay;
+/**
+ * Returns XHTML narrative for one FHIR-like resource, preferring
+ * `resource.text.div` and otherwise deriving a deterministic fallback from
+ * canonical `meta.claims`.
+ */
+export declare function getXhtmlOrDerived(resource: ClinicalResourceLike): string | undefined;
+/**
+ * Returns XHTML plus the source used to obtain it.
+ */
+export declare function getNarrative(resource: ClinicalResourceLike): NarrativeResult;

package/dist/utils/clinical-resource-view.js

@@ -4,7 +4,9 @@ import { ClaimConsent } from '../models/consent-rule.js';
 import { AllergyIntoleranceClaim, AllergyIntoleranceClaimsFhirApi, } from '../models/interoperable-claims/allergy-intolerance-claims.js';
 import { CommunicationClaim } from '../models/interoperable-claims/communication-claims.js';
 import { ConditionClaim, ConditionClaimsFhirApi, } from '../models/interoperable-claims/condition-claims.js';
-import { MedicationStatementClaim, MedicationStatementClaimsFhirApi, } from '../models/interoperable-claims/medication-statement-claims.js';
+import { ImmunizationClaim } from '../models/interoperable-claims/immunization-claims.js';
+import { MedicationStatementClaim, MedicationStatementClaimsFhirApi, MedicationStatementClaimsFhirApiExtended, } from '../models/interoperable-claims/medication-statement-claims.js';
+import { ObservationClaim } from '../models/interoperable-claims/observation-claims.js';
 const CONSENT_ACTOR_REFERENCE_CLAIM = 'Consent.actor-reference';
 const GENERIC_CREATOR_CLAIM_SUFFIX = '.creator';
 const GENERIC_PERFORMER_CLAIM_SUFFIX = '.performer';
@@ -70,6 +72,73 @@ export function toClinicalResourceExpandedView(entry) {
 export function toClinicalResourceExpandedViews(bundle) {
     return readBundleEntries(bundle).map((entry) => toClinicalResourceExpandedView(entry));
 }
+/**
+ * Returns the most useful local text plus international display pair that can
+ * be inferred from one FHIR-like resource and its `meta.claims`.
+ */
+export function getLocalTextAndIntDisplay(resource) {
+    const claims = asRecord(resource?.meta?.claims);
+    const resourceType = resolveResourceType({ resource }, claims);
+    const localText = firstDefinedText([
+        resolveResourceCodeText(resource),
+        findBySuffix(claims, '.code-text'),
+        findBySuffix(claims, '.medication-text'),
+        findBySuffix(claims, '.vaccine-code-text'),
+        findBySuffix(claims, '.value-concept-text'),
+    ]) || resolveTitle(resourceType, claims);
+    const internationalDisplay = firstDefinedText([
+        resolveResourceCodeDisplay(resource),
+        findBySuffix(claims, '.code-display'),
+        findBySuffix(claims, '.vaccine-code-display'),
+        findBySuffix(claims, '.value-concept-display'),
+    ]);
+    const combined = buildCombinedLabel(localText, internationalDisplay);
+    return {
+        ...(localText ? { localText } : {}),
+        ...(internationalDisplay ? { internationalDisplay } : {}),
+        ...(combined ? { combined } : {}),
+    };
+}
+/**
+ * Returns XHTML narrative for one FHIR-like resource, preferring
+ * `resource.text.div` and otherwise deriving a deterministic fallback from
+ * canonical `meta.claims`.
+ */
+export function getXhtmlOrDerived(resource) {
+    return getNarrative(resource).xhtml;
+}
+/**
+ * Returns XHTML plus the source used to obtain it.
+ */
+export function getNarrative(resource) {
+    const fromFhirNarrative = trimValue(asRecord(resource?.text).div);
+    if (fromFhirNarrative) {
+        return {
+            xhtml: fromFhirNarrative,
+            source: 'resource.text.div',
+        };
+    }
+    const claims = asRecord(resource?.meta?.claims);
+    const fromSpecificClaim = findBySuffix(claims, '.xhtml')
+        || findBySuffix(claims, '.text-div');
+    if (fromSpecificClaim) {
+        return {
+            xhtml: fromSpecificClaim,
+            source: 'derived-from-claims',
+        };
+    }
+    const resourceType = resolveResourceType({ resource }, claims);
+    const lines = buildNarrativeLines(resourceType, claims, resource);
+    if (lines.length === 0) {
+        return {
+            source: 'missing',
+        };
+    }
+    return {
+        xhtml: `<div xmlns="http://www.w3.org/1999/xhtml">${lines.map((line) => `<p>${escapeHtml(line)}</p>`).join('')}</div>`,
+        source: 'derived-from-claims',
+    };
+}
 function readClaims(entry) {
     const resourceClaims = asRecord(entry?.resource?.meta?.claims);
     const legacyClaims = asRecord(entry?.meta?.claims);
@@ -284,13 +353,16 @@ function resolveActors(resourceType, claims) {
     return out;
 }
 function resolveXhtml(entry, claims) {
-    const fromFhirNarrative = trimValue(asRecord(entry?.resource?.text).div);
-    if (fromFhirNarrative) {
-        return fromFhirNarrative;
-    }
-    const fromSpecificClaim = findBySuffix(claims, '.xhtml')
-        || findBySuffix(claims, '.text-div');
-    return fromSpecificClaim || undefined;
+    if (!entry?.resource) {
+        return undefined;
+    }
+    const mergedResource = {
+        ...entry.resource,
+        meta: {
+            claims,
+        },
+    };
+    return getXhtmlOrDerived(mergedResource);
 }
 function resolveNotes(entry, resourceType, claims) {
     const notesFromResource = readFhirNoteArray(entry);
@@ -379,6 +451,211 @@ function findBySuffix(claims, keySuffix) {
     }
     return undefined;
 }
+function resolveResourceCodeText(resource) {
+    return trimValue(asRecord(resource?.code).text) || undefined;
+}
+function resolveResourceCodeDisplay(resource) {
+    const coding = asArray(asRecord(resource?.code).coding);
+    for (const item of coding) {
+        const display = trimValue(asRecord(item).display);
+        if (display) {
+            return display;
+        }
+    }
+    return undefined;
+}
+function firstDefinedText(values) {
+    for (const value of values) {
+        const normalized = trimValue(value);
+        if (normalized) {
+            return normalized;
+        }
+    }
+    return undefined;
+}
+function buildCombinedLabel(localText, internationalDisplay) {
+    const local = trimValue(localText);
+    const intl = trimValue(internationalDisplay);
+    if (local && intl && local !== intl) {
+        return `${local} (${intl})`;
+    }
+    return local || intl || undefined;
+}
+function buildNarrativeLines(resourceType, claims, resource) {
+    const lines = [];
+    const label = getLocalTextAndIntDisplay(resource).combined || resolveTitle(resourceType, claims) || resourceType;
+    if (label) {
+        lines.push(label);
+    }
+    const date = resolveDate(resourceType, claims);
+    if (date) {
+        lines.push(`Date: ${date}`);
+    }
+    const periodStart = resolvePeriodStart(resourceType, claims);
+    const periodEnd = resolvePeriodEnd(resourceType, claims);
+    if (periodStart) {
+        lines.push(`Start: ${periodStart}`);
+        if (periodEnd) {
+            lines.push(`End: ${periodEnd}`);
+        }
+    }
+    appendFamilySpecificNarrativeLines(lines, resourceType, claims, resource);
+    return uniqueTokens(lines);
+}
+function appendFamilySpecificNarrativeLines(lines, resourceType, claims, resource) {
+    if (resourceType === ResourceTypesFhirR4.AllergyIntolerance) {
+        pushLine(lines, 'Clinical status', firstClaimValue(claims, [
+            AllergyIntoleranceClaim.ClinicalStatus,
+            AllergyIntoleranceClaimsFhirApi.ClinicalStatus,
+        ]));
+        pushLine(lines, 'Verification status', firstClaimValue(claims, [
+            AllergyIntoleranceClaim.VerificationStatus,
+            AllergyIntoleranceClaimsFhirApi.VerificationStatus,
+        ]));
+        pushLine(lines, 'Criticality', firstClaimValue(claims, [
+            AllergyIntoleranceClaim.Criticality,
+            AllergyIntoleranceClaimsFhirApi.Criticality,
+        ]));
+        pushLine(lines, 'Category', firstClaimCsvValue(claims, [
+            AllergyIntoleranceClaim.Category,
+            AllergyIntoleranceClaimsFhirApi.Category,
+        ]));
+        return;
+    }
+    if (resourceType === ResourceTypesFhirR4.Condition) {
+        pushLine(lines, 'Clinical status', firstClaimValue(claims, [
+            ConditionClaim.ClinicalStatus,
+            ConditionClaimsFhirApi.ClinicalStatus,
+        ]));
+        pushLine(lines, 'Verification status', firstClaimValue(claims, [
+            ConditionClaim.VerificationStatus,
+            ConditionClaimsFhirApi.VerificationStatus,
+        ]));
+        pushLine(lines, 'Severity', firstClaimValue(claims, [
+            ConditionClaim.Severity,
+            ConditionClaimsFhirApi.Severity,
+        ]));
+        pushLine(lines, 'Category', firstClaimCsvValue(claims, [
+            ConditionClaim.Category,
+            ConditionClaimsFhirApi.Category,
+        ]));
+        return;
+    }
+    if (resourceType === ResourceTypesFhirR4.MedicationStatement) {
+        pushLine(lines, 'Status', firstClaimValue(claims, [
+            MedicationStatementClaim.Status,
+            MedicationStatementClaimsFhirApi.Status,
+        ]));
+        pushLine(lines, 'Dose', buildQuantityLabel(firstDefinedText([
+            normalizeNumericValue(claims[MedicationStatementClaimsFhirApiExtended.DoseQuantityValue]),
+            normalizeNumericValue(claims['MedicationStatement.dose-quantity-value']),
+        ]), firstDefinedText([
+            trimValue(claims[MedicationStatementClaimsFhirApiExtended.DoseQuantityUnit]),
+            trimValue(claims['MedicationStatement.dose-quantity-unit']),
+        ])));
+        pushLine(lines, 'Timing', buildMedicationTimingLabel(claims));
+        pushLine(lines, 'Note', firstClaimValue(claims, [MedicationStatementClaim.Note]));
+        return;
+    }
+    if (resourceType === ResourceTypesFhirR4.Immunization) {
+        pushLine(lines, 'Status', trimValue(claims[ImmunizationClaim.Status]));
+        pushLine(lines, 'Vaccine', firstDefinedText([
+            findBySuffix(claims, '.vaccine-code-text'),
+            findBySuffix(claims, '.vaccine-code-display'),
+            trimValue(claims[ImmunizationClaim.VaccineCode]),
+        ]));
+        pushLine(lines, 'Performer', trimValue(claims[ImmunizationClaim.Performer]));
+        pushLine(lines, 'Note', trimValue(claims[ImmunizationClaim.Note]));
+        return;
+    }
+    if (resourceType === ResourceTypesFhirR4.Observation) {
+        appendObservationNarrativeLines(lines, claims, resource);
+    }
+}
+function appendObservationNarrativeLines(lines, claims, resource) {
+    const codeValue = firstDefinedText([
+        trimValue(claims[ObservationClaim.CodeValue]),
+        splitTokenCode(claims[ObservationClaim.Code]),
+    ]);
+    const systolic = normalizeNumericValue(claims[ObservationClaim.BloodPressureSystolicNumber]);
+    const diastolic = normalizeNumericValue(claims[ObservationClaim.BloodPressureDiastolicNumber]);
+    const unit = firstDefinedText([
+        trimValue(claims[ObservationClaim.ValueQuantityUnit]),
+        resolveObservationUnitFromResource(resource),
+    ]);
+    if (codeValue === '85354-9' || systolic || diastolic) {
+        if (systolic) {
+            pushLine(lines, 'Systolic', buildQuantityLabel(systolic, unit));
+        }
+        if (diastolic) {
+            pushLine(lines, 'Diastolic', buildQuantityLabel(diastolic, unit));
+        }
+        return;
+    }
+    const numericValue = normalizeNumericValue(claims[ObservationClaim.ValueQuantityNumber]);
+    if (numericValue || unit) {
+        pushLine(lines, 'Value', buildQuantityLabel(numericValue, unit));
+    }
+    pushLine(lines, 'Note', trimValue(claims[ObservationClaim.Note]));
+}
+function buildMedicationTimingLabel(claims) {
+    const frequency = firstDefinedText([
+        normalizeNumericValue(claims[MedicationStatementClaimsFhirApiExtended.TimingFrequency]),
+        normalizeNumericValue(claims['MedicationStatement.timing-frequency']),
+    ]);
+    const period = firstDefinedText([
+        normalizeNumericValue(claims[MedicationStatementClaimsFhirApiExtended.TimingPeriod]),
+        normalizeNumericValue(claims['MedicationStatement.timing-period']),
+    ]);
+    const unit = firstDefinedText([
+        trimValue(claims[MedicationStatementClaimsFhirApiExtended.TimingPeriodUnit]),
+        trimValue(claims['MedicationStatement.timing-period-unit']),
+    ]);
+    if (!frequency && !period && !unit) {
+        return undefined;
+    }
+    return [frequency ? `${frequency}x` : undefined, period ? `every ${period}` : undefined, unit].filter(Boolean).join(' ');
+}
+function buildQuantityLabel(value, unit) {
+    const normalizedValue = trimValue(value);
+    const normalizedUnit = trimValue(unit);
+    if (normalizedValue && normalizedUnit) {
+        return `${normalizedValue} ${normalizedUnit}`;
+    }
+    return normalizedValue || normalizedUnit || undefined;
+}
+function resolveObservationUnitFromResource(resource) {
+    const valueQuantity = asRecord(resource?.valueQuantity);
+    return trimValue(valueQuantity.unit) || trimValue(valueQuantity.code) || undefined;
+}
+function normalizeNumericValue(value) {
+    const normalized = trimValue(value);
+    return normalized || undefined;
+}
+function splitTokenCode(value) {
+    const normalized = trimValue(value);
+    if (!normalized) {
+        return undefined;
+    }
+    if (!normalized.includes('|')) {
+        return normalized;
+    }
+    const parts = normalized.split('|');
+    return trimValue(parts[parts.length - 1]) || undefined;
+}
+function pushLine(lines, label, value) {
+    const normalized = trimValue(value);
+    if (!normalized) {
+        return;
+    }
+    lines.push(`${label}: ${normalized}`);
+}
+function escapeHtml(value) {
+    return value
+        .replaceAll('&', '&amp;')
+        .replaceAll('<', '&lt;')
+        .replaceAll('>', '&gt;');
+}
 function pushActor(out, actor) {
     const identifier = trimValue(actor.identifier);
     if (!identifier) {
@@ -414,3 +691,6 @@ function asRecord(value) {
     }
     return value;
 }
+function asArray(value) {
+    return Array.isArray(value) ? value : [];
+}

package/dist/utils/legal-organization-onboarding.d.ts

@@ -90,7 +90,7 @@ export declare const LEGAL_ORGANIZATION_ONBOARDING_JSON_SCHEMA: {
  *   canonical `identifier.value`
  *
  * The result shape is intentionally assistant-friendly:
- * - `missingClaims` tells UI/voice flows what is still required
+ * - `missingClaims` tells UI/application flows what is still required
  * - `normalizedClaims` shows the post-derivation claim set
  * - `derived` explains which values were filled automatically
  */

package/dist/utils/legal-organization-onboarding.js

@@ -67,7 +67,7 @@ function normalizeOptionalString(value) {
  *   canonical `identifier.value`
  *
  * The result shape is intentionally assistant-friendly:
- * - `missingClaims` tells UI/voice flows what is still required
+ * - `missingClaims` tells UI/application flows what is still required
  * - `normalizedClaims` shows the post-derivation claim set
  * - `derived` explains which values were filled automatically
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdc-common-utils-ts",
-  "version": "2.0.6",
+  "version": "2.0.8",
   "publishConfig": {
     "access": "public"
   },