gdc-common-utils-ts 2.3.8 → 2.3.9

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

@@ -14,11 +14,11 @@ const GENERIC_ASSERTER_CLAIM_SUFFIX = '.asserter';
 /**
  * Maps one bundle entry to a UI-friendly common clinical view contract.
  */
-export function toClinicalResourceCommonView(entry) {
+export function toClinicalResourceCommonView(entry, options = {}) {
     const claims = readClaims(entry);
     const resourceType = resolveResourceType(entry, claims);
     const resource = entry.resource;
-    const title = resolveTitle(resourceType, claims, resource);
+    const title = resolveTitle(resourceType, claims, resource, options);
     return {
         title,
         resourceType,
@@ -34,14 +34,14 @@ export function toClinicalResourceCommonView(entry) {
 /**
  * Maps all entries from a Bundle into common clinical views.
  */
-export function toClinicalResourceCommonViews(bundle) {
-    return readBundleEntries(bundle).map((entry) => toClinicalResourceCommonView(entry));
+export function toClinicalResourceCommonViews(bundle, options = {}) {
+    return readBundleEntries(bundle).map((entry) => toClinicalResourceCommonView(entry, options));
 }
 /**
  * Maps one bundle entry to a minimal card view for section counters/list cards.
  */
-export function toClinicalResourceCardView(entry) {
-    const common = toClinicalResourceCommonView(entry);
+export function toClinicalResourceCardView(entry, options = {}) {
+    const common = toClinicalResourceCommonView(entry, options);
     return {
         title: common.title,
         resourceType: common.resourceType,
@@ -53,8 +53,8 @@ export function toClinicalResourceCardView(entry) {
 /**
  * Maps all entries from a Bundle into minimal card views.
  */
-export function toClinicalResourceCardViews(bundle) {
-    return readBundleEntries(bundle).map((entry) => toClinicalResourceCardView(entry));
+export function toClinicalResourceCardViews(bundle, options = {}) {
+    return readBundleEntries(bundle).map((entry) => toClinicalResourceCardView(entry, options));
 }
 /**
  * Maps one bundle entry to an expanded view that includes XHTML and notes array.
@@ -128,6 +128,8 @@ export function getLocalTextAndIntDisplay(resource) {
     const localText = firstDefinedText([
         resolveResourceCodeText(resource),
         findBySuffix(claims, '.code-text'),
+        findBySuffix(claims, '.code-text-local'),
+        findBySuffix(claims, '.codetextlocal'),
         findBySuffix(claims, '.medication-text'),
         findBySuffix(claims, '.vaccine-code-text'),
         findBySuffix(claims, '.value-concept-text'),
@@ -135,6 +137,7 @@ export function getLocalTextAndIntDisplay(resource) {
     const internationalDisplay = firstDefinedText([
         resolveResourceCodeDisplay(resource),
         findBySuffix(claims, '.code-display'),
+        findBySuffix(claims, '.codedisplay'),
         findBySuffix(claims, '.vaccine-code-display'),
         findBySuffix(claims, '.value-concept-display'),
     ]);
@@ -204,7 +207,7 @@ function resolveResourceType(entry, claims) {
     }
     return 'Unknown';
 }
-function resolveTitle(resourceType, claims, resource) {
+function resolveTitle(resourceType, claims, resource, options = {}) {
     if (resourceType === ResourceTypesFhirR4.Communication) {
         return (trimValue(claims[CommunicationClaim.ContentAttachmentTitle])
             || trimValue(claims[CommunicationClaim.Text])
@@ -216,20 +219,47 @@ function resolveTitle(resourceType, claims, resource) {
         const firstCategory = splitCsv(claims[ClaimConsent.category])[0];
         const firstAction = splitCsv(claims[ClaimConsent.action])[0];
         const firstPurpose = splitCsv(claims[ClaimConsent.purpose])[0];
-        return firstCategory || firstAction || firstPurpose || resolveFhirResourceTitle(resourceType, resource) || resourceType;
+        const categoryConcept = asArray(resource?.category)[0];
+        return resolveLocalizedCodedTitle({
+            resourceType,
+            claims,
+            resource,
+            options,
+            concept: categoryConcept,
+            token: firstCategory || resolveCodeableConceptToken(categoryConcept),
+        }) || humanTitleCandidate(firstAction) || humanTitleCandidate(firstPurpose) || resourceType;
     }
     if (resourceType === ResourceTypesFhirR4.MedicationStatement) {
         const text = firstClaimValue(claims, [
             MedicationStatementClaim.MedicationText,
             MedicationStatementClaimsFhirApi.Medication,
         ]);
+        const codeText = findFirstClaimBySuffixes(claims, ['.code-text', '.code-text-local', '.codetextlocal']);
+        const codeDisplay = findFirstClaimBySuffixes(claims, ['.code-display', '.codedisplay']);
         const firstCode = firstClaimCsvValue(claims, [
             MedicationStatementClaim.Code,
             MedicationStatementClaimsFhirApi.Code,
         ]);
-        return text || firstCode || resolveFhirResourceTitle(resourceType, resource) || resourceType;
+        return resolveLocalizedCodedTitle({
+            resourceType,
+            claims,
+            resource,
+            options,
+            localText: text || codeText,
+            internationalDisplay: codeDisplay,
+            token: firstCode,
+            concept: resource?.medicationCodeableConcept,
+        }) || resourceType;
     }
     if (resourceType === ResourceTypesFhirR4.Condition) {
+        const codeText = firstClaimValue(claims, [
+            ConditionClaim.CodeText,
+            ConditionClaimsFhirApi.CodeText,
+        ]);
+        const codeDisplay = firstClaimValue(claims, [
+            ConditionClaim.CodeDisplay,
+            ConditionClaimsFhirApi.CodeDisplay,
+        ]);
         const firstCode = firstClaimCsvValue(claims, [
             ConditionClaim.Code,
             ConditionClaimsFhirApi.Code,
@@ -238,9 +268,26 @@ function resolveTitle(resourceType, claims, resource) {
             ConditionClaim.Category,
             ConditionClaimsFhirApi.Category,
         ]);
-        return firstCode || firstCategory || resolveFhirResourceTitle(resourceType, resource) || resourceType;
+        return resolveLocalizedCodedTitle({
+            resourceType,
+            claims,
+            resource,
+            options,
+            localText: codeText,
+            internationalDisplay: codeDisplay,
+            token: firstCode,
+            concept: resource?.code,
+        }) || humanTitleCandidate(firstCategory) || resourceType;
     }
     if (resourceType === ResourceTypesFhirR4.AllergyIntolerance) {
+        const codeText = firstClaimValue(claims, [
+            AllergyIntoleranceClaim.CodeText,
+            AllergyIntoleranceClaimsFhirApi.CodeText,
+        ]);
+        const codeDisplay = firstClaimValue(claims, [
+            AllergyIntoleranceClaim.CodeDisplay,
+            AllergyIntoleranceClaimsFhirApi.CodeDisplay,
+        ]);
         const firstCode = firstClaimCsvValue(claims, [
             AllergyIntoleranceClaim.Code,
             AllergyIntoleranceClaimsFhirApi.Code,
@@ -249,9 +296,72 @@ function resolveTitle(resourceType, claims, resource) {
             AllergyIntoleranceClaim.Category,
             AllergyIntoleranceClaimsFhirApi.Category,
         ]);
-        return firstCode || firstCategory || resolveFhirResourceTitle(resourceType, resource) || resourceType;
-    }
-    return resolveFhirResourceTitle(resourceType, resource) || resourceType;
+        return resolveLocalizedCodedTitle({
+            resourceType,
+            claims,
+            resource,
+            options,
+            localText: codeText,
+            internationalDisplay: codeDisplay,
+            token: firstCode,
+            concept: resource?.code,
+        }) || humanTitleCandidate(firstCategory) || resourceType;
+    }
+    const primaryConcept = resolvePrimaryCodeableConcept(resourceType, resource);
+    return resolveLocalizedCodedTitle({
+        resourceType,
+        claims,
+        resource,
+        options,
+        concept: primaryConcept,
+        token: resolveCodeableConceptToken(primaryConcept),
+    }) || resolveFhirResourceTitle(resourceType, resource) || resourceType;
+}
+function resolveLocalizedCodedTitle(input) {
+    const concept = asRecord(input.concept);
+    const localText = trimValue(input.localText)
+        || trimValue(concept.text)
+        || findFirstClaimBySuffixes(input.claims, ['.code-text', '.code-text-local', '.codetextlocal']);
+    const internationalDisplay = trimValue(input.internationalDisplay)
+        || asArray(concept.coding)
+            .map((coding) => trimValue(asRecord(coding).display))
+            .find(Boolean)
+        || findFirstClaimBySuffixes(input.claims, ['.code-display', '.codedisplay']);
+    const token = trimValue(input.token) || resolveCodeableConceptToken(input.concept);
+    const locale = normalizeLanguage(input.options.locale);
+    const resourceLanguage = normalizeLanguage(trimValue(input.resource?.language)
+        || findBySuffix(input.claims, '.language'));
+    if (!locale) {
+        return localText || internationalDisplay || resolveFhirResourceTitle(input.resourceType, input.resource);
+    }
+    if (resourceLanguage && locale === resourceLanguage && localText) {
+        return localText;
+    }
+    if (locale === 'en') {
+        return internationalDisplay || (resourceLanguage === 'en' ? localText : undefined) || localText;
+    }
+    if (token && input.options.translateCode) {
+        const [system, ...codeParts] = token.split('|');
+        const code = codeParts.length ? codeParts.join('|') : system;
+        const translated = trimValue(input.options.translateCode({
+            resourceType: input.resourceType,
+            ...(codeParts.length ? { system } : {}),
+            code,
+            token,
+            locale,
+        }));
+        if (translated)
+            return translated;
+    }
+    return internationalDisplay || localText || resolveFhirResourceTitle(input.resourceType, input.resource);
+}
+function normalizeLanguage(value) {
+    const normalized = trimValue(value).toLowerCase().replace('_', '-');
+    return normalized ? normalized.split('-')[0] : undefined;
+}
+function humanTitleCandidate(value) {
+    const normalized = trimValue(value);
+    return normalized && !/^\S+\|\S+$/.test(normalized) ? normalized : undefined;
 }
 function resolveIdentifier(resourceType, claims, resource) {
     if (resourceType === ResourceTypesFhirR4.Communication) {
@@ -499,6 +609,9 @@ function findBySuffix(claims, keySuffix) {
     }
     return undefined;
 }
+function findFirstClaimBySuffixes(claims, suffixes) {
+    return firstDefinedText(suffixes.map((suffix) => findBySuffix(claims, suffix)));
+}
 function resolveResourceCodeText(resource) {
     return trimValue(asRecord(resource?.code).text) || undefined;
 }
@@ -512,6 +625,32 @@ function resolveResourceCodeDisplay(resource) {
     }
     return undefined;
 }
+function resolvePrimaryCodeableConcept(resourceType, resource) {
+    if (!resource)
+        return undefined;
+    if (resourceType === ResourceTypesFhirR4.MedicationStatement
+        || resourceType === ResourceTypesFhirR4.MedicationRequest
+        || resourceType === ResourceTypesFhirR4.Medication) {
+        return resource.medicationCodeableConcept || resource.code;
+    }
+    if (resourceType === ResourceTypesFhirR4.Immunization)
+        return resource.vaccineCode;
+    if (resourceType === ResourceTypesFhirR4.Device)
+        return resource.type;
+    if (resourceType === ResourceTypesFhirR4.DocumentReference)
+        return resource.type;
+    if (resourceType === ResourceTypesFhirR4.Specimen)
+        return resource.type;
+    if (resourceType === ResourceTypesFhirR4.ImagingStudy)
+        return asArray(resource.procedureCode)[0];
+    if (resourceType === ResourceTypesFhirR4.PractitionerRole)
+        return asArray(resource.code)[0];
+    if (resourceType === ResourceTypesFhirR4.ImmunizationRecommendation) {
+        const recommendation = asRecord(asArray(resource.recommendation)[0]);
+        return asArray(recommendation.vaccineCode)[0];
+    }
+    return resource.code || asArray(resource.category)[0];
+}
 function resolveFhirResourceTitle(resourceType, resource) {
     if (!resource) {
         return undefined;
@@ -540,18 +679,26 @@ function resolveFhirResourceTitle(resourceType, resource) {
         if (deviceDisplay)
             return deviceDisplay;
     }
-    codeableConceptCandidates.push(resource.code, resource.title, resource.name, resource.description, resource.scope, resource.category);
+    if (resourceType === ResourceTypesFhirR4.Practitioner) {
+        const humanName = asRecord(asArray(resource.name)[0]);
+        const given = asArray(humanName.given).map((value) => trimValue(value)).filter(Boolean);
+        const family = trimValue(humanName.family);
+        const formatted = [...given, ...(family ? [family] : [])].join(' ').trim();
+        if (formatted)
+            return formatted;
+    }
+    codeableConceptCandidates.push(resource.code, resource.title, resource.name, resource.description, resource.summary, resource.scope, resource.category);
     for (const candidate of codeableConceptCandidates) {
         const plainText = trimValue(candidate);
         if (plainText && typeof candidate !== 'object') {
             return plainText;
         }
-        const label = resolveCodeableConceptLabel(candidate);
+        const label = resolveCodeableConceptPreferredLabel(candidate);
         if (label) {
             return label;
         }
         for (const item of asArray(candidate)) {
-            const arrayLabel = resolveCodeableConceptLabel(item);
+            const arrayLabel = resolveCodeableConceptPreferredLabel(item);
             if (arrayLabel)
                 return arrayLabel;
         }
@@ -657,6 +804,20 @@ function resolveCodeableConceptLabel(value) {
         .find(Boolean);
     return buildCombinedLabel(localText, internationalDisplay);
 }
+/**
+ * Compact clinical cards show one human label. The local FHIR
+ * `CodeableConcept.text` wins; the terminology `Coding.display` is the
+ * English/international fallback. `system|code` is never treated as a label.
+ */
+function resolveCodeableConceptPreferredLabel(value) {
+    const concept = asRecord(value);
+    const localText = trimValue(concept.text) || undefined;
+    if (localText)
+        return localText;
+    return asArray(concept.coding)
+        .map((coding) => trimValue(asRecord(coding).display))
+        .find(Boolean);
+}
 function resolveCodeableConceptToken(value) {
     const coding = asArray(asRecord(value).coding)
         .map((item) => asRecord(item))

package/dist/utils/condition-entry-editor.d.ts

@@ -13,6 +13,14 @@ export declare class ConditionEntryEditor extends ClinicalResourceEntryEditor {
     getSubject(): string | undefined;
     setCode(code?: string | null): this;
     getCode(): string | undefined;
+    /** Writes the local-language condition name projected to FHIR `code.text`. */
+    setCodeTextLocal(text?: string | null): this;
+    /** Reads the local-language condition name. */
+    getCodeTextLocal(): string | undefined;
+    /** Writes the English/international terminology display. */
+    setCodeDisplay(display?: string | null): this;
+    /** Reads the English/international terminology display. */
+    getCodeDisplay(): string | undefined;
     setClinicalStatus(status?: string | null): this;
     getClinicalStatus(): string | undefined;
     setVerificationStatus(status?: string | null): this;

package/dist/utils/condition-entry-editor.js

@@ -16,6 +16,14 @@ export class ConditionEntryEditor extends ClinicalResourceEntryEditor {
     getSubject() { return this.getSubjectClaims(ConditionClaim.Subject, ConditionClaim.Subject); }
     setCode(code) { return this.setScalarClaim(ConditionClaim.Code, code); }
     getCode() { return this.getScalarClaim(ConditionClaim.Code); }
+    /** Writes the local-language condition name projected to FHIR `code.text`. */
+    setCodeTextLocal(text) { return this.setScalarClaim(ConditionClaim.CodeText, text); }
+    /** Reads the local-language condition name. */
+    getCodeTextLocal() { return this.getScalarClaim(ConditionClaim.CodeText); }
+    /** Writes the English/international terminology display. */
+    setCodeDisplay(display) { return this.setScalarClaim(ConditionClaim.CodeDisplay, display); }
+    /** Reads the English/international terminology display. */
+    getCodeDisplay() { return this.getScalarClaim(ConditionClaim.CodeDisplay); }
     setClinicalStatus(status) { return this.setScalarClaim(ConditionClaim.ClinicalStatus, status); }
     getClinicalStatus() { return this.getScalarClaim(ConditionClaim.ClinicalStatus); }
     setVerificationStatus(status) { return this.setScalarClaim(ConditionClaim.VerificationStatus, status); }

package/dist/utils/diagnostic-report-entry-editor.d.ts

@@ -39,6 +39,14 @@ export declare class DiagnosticReportEntryEditor extends ClinicalResourceEntryEd
     setCode(code?: string | null): this;
     /** Returns the main report code. */
     getCode(): string | undefined;
+    /** Sets the local-language report name projected to FHIR `code.text`. */
+    setCodeTextLocal(text?: string | null): this;
+    /** Returns the local-language report name. */
+    getCodeTextLocal(): string | undefined;
+    /** Sets the English/international terminology display. */
+    setCodeDisplay(display?: string | null): this;
+    /** Returns the English/international terminology display. */
+    getCodeDisplay(): string | undefined;
     /** Sets the encounter reference linked to this report. */
     setEncounter(reference?: string | null): this;
     /** Returns the encounter reference linked to this report. */

package/dist/utils/diagnostic-report-entry-editor.js

@@ -68,6 +68,22 @@ export class DiagnosticReportEntryEditor extends ClinicalResourceEntryEditor {
     getCode() {
         return this.getScalarClaim(DiagnosticReportClaim.Code);
     }
+    /** Sets the local-language report name projected to FHIR `code.text`. */
+    setCodeTextLocal(text) {
+        return this.setScalarClaim(DiagnosticReportClaim.CodeText, text);
+    }
+    /** Returns the local-language report name. */
+    getCodeTextLocal() {
+        return this.getScalarClaim(DiagnosticReportClaim.CodeText);
+    }
+    /** Sets the English/international terminology display. */
+    setCodeDisplay(display) {
+        return this.setScalarClaim(DiagnosticReportClaim.CodeDisplay, display);
+    }
+    /** Returns the English/international terminology display. */
+    getCodeDisplay() {
+        return this.getScalarClaim(DiagnosticReportClaim.CodeDisplay);
+    }
     /** Sets the encounter reference linked to this report. */
     setEncounter(reference) {
         return this.setScalarClaim(DiagnosticReportClaim.Encounter, reference);

package/dist/utils/flag-entry-editor.d.ts

@@ -28,6 +28,14 @@ export declare class FlagEntryEditor extends ClinicalResourceEntryEditor {
     setCode(value?: string | null): this;
     /** Reads the flag code. */
     getCode(): string | undefined;
+    /** Writes the local-language alert name projected to FHIR `code.text`. */
+    setCodeTextLocal(value?: string | null): this;
+    /** Reads the local-language alert name. */
+    getCodeTextLocal(): string | undefined;
+    /** Writes the English/international terminology display. */
+    setCodeDisplay(value?: string | null): this;
+    /** Reads the English/international terminology display. */
+    getCodeDisplay(): string | undefined;
     /** Writes the flag date. */
     setDate(value?: string | null): this;
     /** Reads the flag date. */

package/dist/utils/flag-entry-editor.js

@@ -31,6 +31,14 @@ export class FlagEntryEditor extends ClinicalResourceEntryEditor {
     setCode(value) { return this.setScalarClaim(FlagClaim.Code, value); }
     /** Reads the flag code. */
     getCode() { return this.getScalarClaim(FlagClaim.Code); }
+    /** Writes the local-language alert name projected to FHIR `code.text`. */
+    setCodeTextLocal(value) { return this.setScalarClaim(FlagClaim.CodeText, value); }
+    /** Reads the local-language alert name. */
+    getCodeTextLocal() { return this.getScalarClaim(FlagClaim.CodeText); }
+    /** Writes the English/international terminology display. */
+    setCodeDisplay(value) { return this.setScalarClaim(FlagClaim.CodeDisplay, value); }
+    /** Reads the English/international terminology display. */
+    getCodeDisplay() { return this.getScalarClaim(FlagClaim.CodeDisplay); }
     /** Writes the flag date. */
     setDate(value) { return this.setScalarClaim(FlagClaim.Date, value); }
     /** Reads the flag date. */

package/dist/utils/medication-statement-entry-editor.d.ts

@@ -39,6 +39,14 @@ export declare class MedicationStatementEntryEditor extends ClinicalResourceEntr
     setMedicationText(text?: string | null): this;
     /** Returns the human-readable medication text. */
     getMedicationText(): string | undefined;
+    /** Alias used consistently by coded IPS editors for local FHIR text. */
+    setCodeTextLocal(text?: string | null): this;
+    /** Returns the local-language medication text. */
+    getCodeTextLocal(): string | undefined;
+    /** Sets the English/international terminology display. */
+    setCodeDisplay(display?: string | null): this;
+    /** Returns the English/international terminology display. */
+    getCodeDisplay(): string | undefined;
     /** Sets one free-text note attached to the medication entry. */
     setNote(note?: string | null): this;
     /** Returns the current medication note. */

package/dist/utils/medication-statement-entry-editor.js

@@ -42,6 +42,14 @@ export class MedicationStatementEntryEditor extends ClinicalResourceEntryEditor
     setMedicationText(text) { return this.setScalarClaim(MedicationStatementClaim.MedicationText, text); }
     /** Returns the human-readable medication text. */
     getMedicationText() { return this.getScalarClaim(MedicationStatementClaim.MedicationText); }
+    /** Alias used consistently by coded IPS editors for local FHIR text. */
+    setCodeTextLocal(text) { return this.setMedicationText(text); }
+    /** Returns the local-language medication text. */
+    getCodeTextLocal() { return this.getMedicationText(); }
+    /** Sets the English/international terminology display. */
+    setCodeDisplay(display) { return this.setScalarClaim(MedicationStatementClaim.CodeDisplay, display); }
+    /** Returns the English/international terminology display. */
+    getCodeDisplay() { return this.getScalarClaim(MedicationStatementClaim.CodeDisplay); }
     /** Sets one free-text note attached to the medication entry. */
     setNote(note) { return this.setScalarClaim(MedicationStatementClaim.Note, note); }
     /** Returns the current medication note. */