gdc-sdk-front-ts 2.2.1 → 2.3.0

package/dist/gdc-common-utils-ts/src/utils/clinical-resource-view.js

@@ -1,291 +0,0 @@
-// Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
-import { ResourceTypesFhirR4 } from '../constants/fhir-resource-types.js';
-import { ClaimConsent } from '../models/consent-rule.js';
-import { CommunicationClaim } from '../models/interoperable-claims/communication-claims.js';
-import { MedicationStatementClaim } from '../models/interoperable-claims/medication-statement-claims.js';
-const CONSENT_ACTOR_REFERENCE_CLAIM = 'Consent.actor-reference';
-const GENERIC_CREATOR_CLAIM_SUFFIX = '.creator';
-const GENERIC_PERFORMER_CLAIM_SUFFIX = '.performer';
-const GENERIC_ASSERTER_CLAIM_SUFFIX = '.asserter';
-/**
- * Maps one bundle entry to a UI-friendly common clinical view contract.
- */
-export function toClinicalResourceCommonView(entry) {
-    const claims = readClaims(entry);
-    const resourceType = resolveResourceType(entry, claims);
-    const title = resolveTitle(resourceType, claims);
-    return {
-        title,
-        resourceType,
-        identifier: resolveIdentifier(resourceType, claims),
-        date: resolveDate(resourceType, claims),
-        periodStart: resolvePeriodStart(resourceType, claims),
-        periodEnd: resolvePeriodEnd(resourceType, claims),
-        fullUrl: trimValue(entry.fullUrl),
-        actors: resolveActors(resourceType, claims),
-        claims,
-    };
-}
-/**
- * Maps all entries from a Bundle into common clinical views.
- */
-export function toClinicalResourceCommonViews(bundle) {
-    return Array.isArray(bundle?.data)
-        ? bundle.data.map((entry) => toClinicalResourceCommonView(entry))
-        : [];
-}
-/**
- * Maps one bundle entry to a minimal card view for section counters/list cards.
- */
-export function toClinicalResourceCardView(entry) {
-    const common = toClinicalResourceCommonView(entry);
-    return {
-        title: common.title,
-        resourceType: common.resourceType,
-        date: common.date,
-        fullUrl: common.fullUrl,
-        actorsCount: common.actors.length,
-    };
-}
-/**
- * Maps all entries from a Bundle into minimal card views.
- */
-export function toClinicalResourceCardViews(bundle) {
-    return Array.isArray(bundle?.data)
-        ? bundle.data.map((entry) => toClinicalResourceCardView(entry))
-        : [];
-}
-/**
- * Maps one bundle entry to an expanded view that includes XHTML and notes array.
- */
-export function toClinicalResourceExpandedView(entry) {
-    const common = toClinicalResourceCommonView(entry);
-    return {
-        common,
-        xhtml: resolveXhtml(entry, common.claims),
-        notes: resolveNotes(entry, common.resourceType, common.claims),
-    };
-}
-/**
- * Maps all entries from a Bundle into expanded views.
- */
-export function toClinicalResourceExpandedViews(bundle) {
-    return Array.isArray(bundle?.data)
-        ? bundle.data.map((entry) => toClinicalResourceExpandedView(entry))
-        : [];
-}
-function readClaims(entry) {
-    const resourceClaims = asRecord(entry?.resource?.meta?.claims);
-    const legacyClaims = asRecord(entry?.meta?.claims);
-    return {
-        ...legacyClaims,
-        ...resourceClaims,
-    };
-}
-function resolveResourceType(entry, claims) {
-    const fromClaim = trimValue(claims[ClaimConsent.resourceType]);
-    if (fromClaim) {
-        return fromClaim;
-    }
-    const fromResource = trimValue(entry?.resource?.resourceType);
-    if (fromResource) {
-        return fromResource;
-    }
-    return 'Unknown';
-}
-function resolveTitle(resourceType, claims) {
-    if (resourceType === ResourceTypesFhirR4.Communication) {
-        return (trimValue(claims[CommunicationClaim.ContentAttachmentTitle])
-            || trimValue(claims[CommunicationClaim.Text])
-            || trimValue(claims[CommunicationClaim.NoteText])
-            || resourceType);
-    }
-    if (resourceType === ResourceTypesFhirR4.Consent) {
-        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 || resourceType;
-    }
-    if (resourceType === ResourceTypesFhirR4.MedicationStatement) {
-        const text = trimValue(claims[MedicationStatementClaim.MedicationText]);
-        const firstCode = splitCsv(claims[MedicationStatementClaim.Code])[0];
-        return text || firstCode || resourceType;
-    }
-    return resourceType;
-}
-function resolveIdentifier(resourceType, claims) {
-    if (resourceType === ResourceTypesFhirR4.Communication) {
-        return trimValue(claims[CommunicationClaim.Identifier]);
-    }
-    if (resourceType === ResourceTypesFhirR4.Consent) {
-        return trimValue(claims[ClaimConsent.identifier]);
-    }
-    if (resourceType === ResourceTypesFhirR4.MedicationStatement) {
-        return trimValue(claims[MedicationStatementClaim.Identifier]);
-    }
-    return undefined;
-}
-function resolveDate(resourceType, claims) {
-    if (resourceType === ResourceTypesFhirR4.Communication) {
-        return trimValue(claims[CommunicationClaim.Sent]);
-    }
-    if (resourceType === ResourceTypesFhirR4.Consent) {
-        return trimValue(claims[ClaimConsent.date]);
-    }
-    if (resourceType === ResourceTypesFhirR4.MedicationStatement) {
-        return trimValue(claims[MedicationStatementClaim.Effective]);
-    }
-    const genericDate = findBySuffix(claims, '.date');
-    return genericDate || undefined;
-}
-function resolvePeriodStart(resourceType, claims) {
-    if (resourceType === ResourceTypesFhirR4.Consent) {
-        return trimValue(claims[ClaimConsent.periodStart]);
-    }
-    return findBySuffix(claims, '.period-start') || undefined;
-}
-function resolvePeriodEnd(resourceType, claims) {
-    if (resourceType === ResourceTypesFhirR4.Consent) {
-        return trimValue(claims[ClaimConsent.periodEnd]);
-    }
-    return findBySuffix(claims, '.period-end') || undefined;
-}
-function resolveActors(resourceType, claims) {
-    const out = [];
-    if (resourceType === ResourceTypesFhirR4.Consent) {
-        const identifiers = splitCsv(claims[ClaimConsent.actorIdentifier]);
-        const roles = splitCsv(claims[ClaimConsent.actorRole]);
-        const references = splitCsv(claims[CONSENT_ACTOR_REFERENCE_CLAIM]);
-        identifiers.forEach((identifier, index) => {
-            pushActor(out, {
-                identifier,
-                role: roles[index] || roles[0],
-                type: 'actor',
-            });
-        });
-        references.forEach((identifier, index) => {
-            pushActor(out, {
-                identifier,
-                role: roles[index] || roles[0],
-                type: 'actor-reference',
-            });
-        });
-    }
-    if (resourceType === ResourceTypesFhirR4.Communication) {
-        splitCsv(claims[CommunicationClaim.Sender]).forEach((identifier) => {
-            pushActor(out, { identifier, type: 'sender' });
-        });
-        splitCsv(claims[CommunicationClaim.Recipient]).forEach((identifier) => {
-            pushActor(out, { identifier, type: 'recipient' });
-        });
-    }
-    if (resourceType === ResourceTypesFhirR4.MedicationStatement) {
-        splitCsv(claims[MedicationStatementClaim.Source]).forEach((identifier) => {
-            pushActor(out, { identifier, type: 'source' });
-        });
-        splitCsv(claims[MedicationStatementClaim.Subject]).forEach((identifier) => {
-            pushActor(out, { identifier, type: 'subject' });
-        });
-    }
-    appendGenericActorType(out, claims, GENERIC_CREATOR_CLAIM_SUFFIX, 'creator');
-    appendGenericActorType(out, claims, GENERIC_PERFORMER_CLAIM_SUFFIX, 'performer');
-    appendGenericActorType(out, claims, GENERIC_ASSERTER_CLAIM_SUFFIX, 'asserter');
-    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;
-}
-function resolveNotes(entry, resourceType, claims) {
-    const notesFromResource = readFhirNoteArray(entry);
-    const notesFromClaims = readNotesFromClaims(resourceType, claims);
-    return uniqueTokens([...notesFromResource, ...notesFromClaims]);
-}
-function readFhirNoteArray(entry) {
-    const rawNotes = entry?.resource?.note;
-    if (!Array.isArray(rawNotes)) {
-        return [];
-    }
-    return uniqueTokens(rawNotes
-        .map((item) => trimValue(asRecord(item).text))
-        .filter(Boolean));
-}
-function readNotesFromClaims(resourceType, claims) {
-    const out = [];
-    if (resourceType === ResourceTypesFhirR4.Communication) {
-        out.push(...splitCsv(claims[CommunicationClaim.NoteText]));
-    }
-    if (resourceType === ResourceTypesFhirR4.MedicationStatement) {
-        out.push(...splitCsv(claims[MedicationStatementClaim.Note]));
-    }
-    for (const [key, value] of Object.entries(claims)) {
-        if (String(key || '').toLowerCase().endsWith('.note')) {
-            out.push(...splitCsv(value));
-        }
-    }
-    return uniqueTokens(out);
-}
-function appendGenericActorType(out, claims, keySuffix, actorType) {
-    for (const [key, value] of Object.entries(claims)) {
-        if (!String(key || '').toLowerCase().endsWith(keySuffix)) {
-            continue;
-        }
-        splitCsv(value).forEach((identifier) => {
-            pushActor(out, {
-                identifier,
-                type: actorType,
-            });
-        });
-    }
-}
-function findBySuffix(claims, keySuffix) {
-    for (const [key, value] of Object.entries(claims)) {
-        if (String(key || '').toLowerCase().endsWith(keySuffix)) {
-            const normalized = trimValue(value);
-            if (normalized) {
-                return normalized;
-            }
-        }
-    }
-    return undefined;
-}
-function pushActor(out, actor) {
-    const identifier = trimValue(actor.identifier);
-    if (!identifier) {
-        return;
-    }
-    const role = trimValue(actor.role);
-    const candidate = {
-        identifier,
-        role: role || undefined,
-        type: actor.type,
-    };
-    const dedupeKey = `${candidate.type}|${candidate.identifier}|${candidate.role || ''}`;
-    const exists = out.some((item) => `${item.type}|${item.identifier}|${item.role || ''}` === dedupeKey);
-    if (!exists) {
-        out.push(candidate);
-    }
-}
-function splitCsv(value) {
-    return String(value || '')
-        .split(',')
-        .map((item) => item.trim())
-        .filter(Boolean);
-}
-function uniqueTokens(values) {
-    return [...new Set(values.map((item) => String(item || '').trim()).filter(Boolean))];
-}
-function trimValue(value) {
-    return String(value || '').trim();
-}
-function asRecord(value) {
-    if (!value || typeof value !== 'object' || Array.isArray(value)) {
-        return {};
-    }
-    return value;
-}

package/dist/gdc-common-utils-ts/src/utils/communication-bundle-session.d.ts

@@ -1,110 +0,0 @@
-import { BundleEntry, BundleJsonApi, BundleRequest } from '../models/bundle';
-import { type BundleResourceIdFilters } from './bundle-query';
-import { type MedicationStatementClaimsFlat } from '../models/interoperable-claims/medication-statement-claims';
-export type CommunicationBundleSessionMode = 'strict' | 'normalize';
-export type CommunicationBundleSessionOptions = Readonly<{
-    communicationClaims?: Record<string, unknown>;
-    initialBundle?: BundleJsonApi<BundleEntry>;
-    mode?: CommunicationBundleSessionMode;
-}>;
-export type ActiveEntrySelection = Readonly<{
-    index?: number;
-    fullUrl?: string;
-}>;
-export type UpsertEntryInput = Readonly<{
-    resourceType: string;
-    claims: Record<string, unknown>;
-    type?: string;
-    fullUrl?: string;
-    request?: BundleRequest;
-}>;
-/**
- * Communication editing session with bundle-in-memory as source of truth.
- *
- * Design contract:
- * - `activeEntry` is the real editing unit (not only `activeResource`), because
- *   it can include `fullUrl`, `request`, and entry-level context.
- * - `Communication.content-attachment-data` is always derived from the
- *   in-memory bundle after each committed update.
- * - saving can release active entry memory via `saveAndReleaseActiveEntry()`.
- */
-export declare class CommunicationBundleSession {
-    private communicationClaims;
-    private bundleInMemory;
-    private activeEntryIndex;
-    private mode;
-    constructor(options?: CommunicationBundleSessionOptions);
-    /** Returns a deep copy of communication claims. */
-    getCommunicationClaims(): Record<string, unknown>;
-    /** Returns a deep copy of the current in-memory bundle. */
-    getBundleInMemory(): BundleJsonApi<BundleEntry>;
-    /** Returns the active entry index, or null when no entry is selected. */
-    getActiveEntryIndex(): number | null;
-    /** Returns a deep copy of the active entry when selected. */
-    getActiveEntry(): BundleEntry | null;
-    /** Selects an active entry by index or fullUrl. */
-    selectActiveEntry(selection: ActiveEntrySelection): this;
-    /** Clears active entry selection from memory. */
-    clearActiveEntry(): this;
-    /**
-     * Upserts an entry in bundle memory and marks it as active.
-     * Matching priority: `fullUrl` if present, then resource claim identifier.
-     */
-    upsertActiveEntry(input: UpsertEntryInput): this;
-    /**
-     * Consent-first helper for developer onboarding.
-     *
-     * Expected keys should come from `ClaimConsent` in caller code.
-     */
-    upsertActiveConsentEntry(input: Readonly<{
-        claims: Record<string, unknown>;
-        fullUrl?: string;
-        type?: string;
-        request?: BundleRequest;
-    }>): this;
-    /**
-     * MedicationStatement helper for IPS-in-Communication use cases.
-     *
-     * Expected keys should come from MedicationStatement claims constants.
-     */
-    upsertActiveMedicationStatementEntry(input: Readonly<{
-        claims: MedicationStatementClaimsFlat | Record<string, unknown>;
-        fullUrl?: string;
-        type?: string;
-        request?: BundleRequest;
-    }>): this;
-    /**
-     * Patches active entry `resource.meta.claims` and synchronizes attachment data.
-     */
-    patchActiveEntryClaims(claimPatch: Record<string, unknown>): this;
-    /**
-     * Persists current memory state into communication claims attachment.
-     * No-op for active entry pointer.
-     */
-    saveActiveEntry(): this;
-    /**
-     * Persists and releases active entry memory pointer.
-     * This is the recommended step after a successful save operation.
-     */
-    saveAndReleaseActiveEntry(): this;
-    /**
-     * Returns stable resource IDs from bundle entries with optional filters.
-     */
-    getResourceIds(filters?: BundleResourceIdFilters): string[];
-    /**
-     * Returns bundle entries matching resource IDs produced by `getResourceIds`.
-     */
-    getResourceEntriesByIds(resourceIds: readonly string[]): BundleEntry[];
-    /**
-     * Resolves the entry URL (`fullUrl`) for a given entry/resource identifier.
-     */
-    getEntryUrl(entryId: string): string | undefined;
-    private decodeBundleFromClaims;
-    private syncAttachmentFromBundle;
-    private resolveCurrentSubject;
-    private findUpsertIndex;
-    private resolveEntryIdentifier;
-    private createBundleEntry;
-    private resolveEntryCanonicalIdValue;
-    private assertEntryIndex;
-}