vet-data-utils-ts 0.5.8 → 0.5.9

package/README.md

@@ -85,6 +85,16 @@ for immunologicals); ordinary human ATC is not substituted for it. Veterinary
 allergy product coding may also use ATCvet, while manifestations use an allowed
 SNOMED source.
 
+The shared IPS reader boundary is `projectClinicalBundleForReading(...)` from
+`vet-data-utils-ts/clinical-bundle-reader`. It accepts a native FHIR Bundle
+(including R4/R5 resources supported by the common normalizer) or resources
+already carrying canonical `meta.claims`, creates a presentation-only copy,
+and fills the governed primary `*-text`/`*-display` claims through an injected
+exact terminology resolver. The resolver is called with `system`, `code` and
+locale; the original verified Bundle is never mutated. Local UI labels render
+as `text (English display)` outside English, English renders only `display`,
+and missing labels fall back to the canonical `system|code` token.
+
 The deferred spreadsheet shape for member and employee role assignments is
 documented in [`docs/member-import-contract.md`](docs/member-import-contract.md).
 It is not an implemented importer API.

package/dist/clinical-bundle-reader.d.ts

@@ -0,0 +1,28 @@
+export type ClinicalTerminologyLookupRequest = Readonly<{
+    resourceType: string;
+    field: string;
+    system: string;
+    code: string;
+    version?: string;
+    language: string;
+}>;
+export type ClinicalTerminologyLabels = Readonly<{
+    text?: string;
+    display?: string;
+}>;
+export type ClinicalBundleReaderOptions = Readonly<{
+    language: string;
+    resolveTerminology(request: ClinicalTerminologyLookupRequest): Promise<ClinicalTerminologyLabels>;
+}>;
+/**
+ * Creates a presentation-only Bundle for the shared IPS reader. Native FHIR
+ * and already-normalized `resource.meta.claims` converge on the same flat
+ * claims without changing the verified/signed input.
+ */
+export declare function projectClinicalBundleForReading<T extends Record<string, unknown>>(bundle: T, options: ClinicalBundleReaderOptions): Promise<T>;
+export declare function formatLocalizedTerminologyLabel(input: Readonly<{
+    code: string;
+    text?: string;
+    display?: string;
+    language: string;
+}>): string;

package/dist/clinical-bundle-reader.js

@@ -0,0 +1,100 @@
+import { normalizeClaimsFromFhirResource } from 'gdc-common-utils-ts/utils/interoperable-resource-operation';
+const PRIMARY_CODE_PROJECTIONS = Object.freeze({
+    Condition: { field: 'Condition.code', code: 'Condition.code', text: 'Condition.code-text', display: 'Condition.code-display' },
+    Procedure: { field: 'Procedure.code', code: 'Procedure.code', text: 'Procedure.code-text', display: 'Procedure.code-display' },
+    DiagnosticReport: { field: 'DiagnosticReport.code', code: 'DiagnosticReport.code', text: 'DiagnosticReport.code-text', display: 'DiagnosticReport.code-display' },
+    Observation: { field: 'Observation.code', code: 'Observation.code', text: 'Observation.code-text', display: 'Observation.code-display' },
+    AllergyIntolerance: { field: 'AllergyIntolerance.code', code: 'AllergyIntolerance.code', text: 'AllergyIntolerance.code-text', display: 'AllergyIntolerance.code-display' },
+    Immunization: { field: 'Immunization.vaccineCode', code: 'Immunization.vaccine-code', text: 'Immunization.vaccine-code-text', display: 'Immunization.vaccine-code-display' },
+});
+/**
+ * Creates a presentation-only Bundle for the shared IPS reader. Native FHIR
+ * and already-normalized `resource.meta.claims` converge on the same flat
+ * claims without changing the verified/signed input.
+ */
+export async function projectClinicalBundleForReading(bundle, options) {
+    if (bundle.resourceType !== 'Bundle' || !Array.isArray(bundle.entry)) {
+        throw new TypeError('clinical_bundle_required');
+    }
+    const projected = structuredClone(bundle);
+    const entries = projected.entry;
+    for (const entry of entries) {
+        const resource = asRecord(entry.resource);
+        if (!resource.resourceType)
+            continue;
+        entry.resource = await projectResource(resource, options);
+    }
+    return projected;
+}
+export function formatLocalizedTerminologyLabel(input) {
+    const text = clean(input.text);
+    const display = clean(input.display);
+    const language = input.language.trim().toLowerCase().split(/[-_]/)[0];
+    if (language === 'en')
+        return display || text || input.code;
+    if (text && display && text.localeCompare(display, undefined, { sensitivity: 'accent' }) !== 0) {
+        return `${text} (${display})`;
+    }
+    return text || display || input.code;
+}
+async function projectResource(resource, options) {
+    const resourceType = clean(resource.resourceType);
+    const existingMeta = asRecord(resource.meta);
+    const existingClaims = asRecord(existingMeta.claims);
+    const claims = Object.keys(existingClaims).length
+        ? { ...existingClaims }
+        : normalizeClaimsFromFhirResource(resource, {});
+    const projection = PRIMARY_CODE_PROJECTIONS[resourceType];
+    if (projection) {
+        const token = firstToken(claims[projection.code]);
+        const parsed = parseCodingToken(token);
+        const needsText = !clean(claims[projection.text]);
+        const needsDisplay = !clean(claims[projection.display]);
+        if (parsed && (needsText || needsDisplay)) {
+            const labels = await options.resolveTerminology({
+                resourceType,
+                field: projection.field,
+                ...parsed,
+                language: options.language,
+            });
+            if (needsText && clean(labels.text))
+                claims[projection.text] = clean(labels.text);
+            if (needsDisplay && clean(labels.display))
+                claims[projection.display] = clean(labels.display);
+        }
+    }
+    return {
+        ...resource,
+        language: clean(resource.language) || options.language,
+        meta: { ...existingMeta, claims },
+    };
+}
+function parseCodingToken(value) {
+    const separator = value.lastIndexOf('|');
+    if (separator <= 0 || separator === value.length - 1)
+        return undefined;
+    const systemAndVersion = value.slice(0, separator);
+    const code = value.slice(separator + 1);
+    const versionSeparator = systemAndVersion.indexOf('|');
+    if (versionSeparator > 0) {
+        return {
+            system: systemAndVersion.slice(0, versionSeparator),
+            version: systemAndVersion.slice(versionSeparator + 1),
+            code,
+        };
+    }
+    return { system: systemAndVersion, code };
+}
+function firstToken(value) {
+    if (Array.isArray(value))
+        return clean(value[0]);
+    return clean(value).split(',')[0]?.trim() ?? '';
+}
+function asRecord(value) {
+    return value && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : {};
+}
+function clean(value) {
+    return typeof value === 'string' ? value.trim() : '';
+}

package/dist/index.d.ts

@@ -2,6 +2,7 @@ export * from './animal-card.js';
 export * from './assistant.js';
 export * from './communication.js';
 export * from './clinical-terminology.js';
+export * from './clinical-bundle-reader.js';
 export * from './digital-twin.js';
 export * from './emergency.js';
 export * from './financial.js';

package/dist/index.js

@@ -2,6 +2,7 @@ export * from './animal-card.js';
 export * from './assistant.js';
 export * from './communication.js';
 export * from './clinical-terminology.js';
+export * from './clinical-bundle-reader.js';
 export * from './digital-twin.js';
 export * from './emergency.js';
 export * from './financial.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vet-data-utils-ts",
-  "version": "0.5.8",
+  "version": "0.5.9",
   "description": "Browser-safe governed VetChain data contracts",
   "license": "Apache-2.0",
   "author": "Connecting Solution & Applications Ltd",
@@ -24,6 +24,10 @@
       "types": "./dist/clinical-terminology.d.ts",
       "default": "./dist/clinical-terminology.js"
     },
+    "./clinical-bundle-reader": {
+      "types": "./dist/clinical-bundle-reader.d.ts",
+      "default": "./dist/clinical-bundle-reader.js"
+    },
     "./digital-twin": {
       "types": "./dist/digital-twin.d.ts",
       "default": "./dist/digital-twin.js"