gdc-common-utils-ts 2.1.0 → 2.3.0

package/dist/utils/vital-sign-day-batch.js

@@ -0,0 +1,115 @@
+// Copyright 2026 Antifraud Services Inc. under the Apache License, Version 2.0.
+import { createCanonicalIdentifierUrn } from './bundle-editor-helpers.js';
+import { BundleQuery } from './bundle-query.js';
+export const VitalSignDayBatchClaim = Object.freeze({
+    Identifier: 'VitalSignDayBatch.identifier',
+    Subject: 'VitalSignDayBatch.subject',
+    Actor: 'VitalSignDayBatch.actor',
+    Day: 'VitalSignDayBatch.day',
+    CreatedAtTimestamp: 'VitalSignDayBatch.createdAtTimestamp',
+});
+export function buildVitalSignDayBatchClaims(input) {
+    const day = resolveDayKey(input.date);
+    const claims = {
+        [VitalSignDayBatchClaim.Subject]: asTrimmedString(input.subject),
+        [VitalSignDayBatchClaim.Actor]: asTrimmedString(input.actor),
+        [VitalSignDayBatchClaim.Day]: day,
+    };
+    if (typeof input.createdAtTimestamp === 'number' && Number.isFinite(input.createdAtTimestamp)) {
+        claims[VitalSignDayBatchClaim.CreatedAtTimestamp] = input.createdAtTimestamp;
+    }
+    return claims;
+}
+export function resolveVitalSignDayBatchId(input) {
+    const baseBundle = cloneBundle(input.bundle || createEmptyBundle());
+    const day = resolveDayKey(input.date);
+    const dayRange = resolveDayRange(day);
+    const existingClaims = asRecord(baseBundle.meta?.claims);
+    const query = new BundleQuery(baseBundle);
+    const dayEntryIds = query.getResourceIds({ dateFrom: dayRange.from, dateTo: dayRange.to });
+    const dayEntries = query.getResourceEntriesByIds(dayEntryIds);
+    const matchingDayEntry = dayEntries.find((entry) => matchesBatchOwner(entry, input.subject, input.actor));
+    const sameOwner = matchesBatchOwnerClaims(existingClaims, input.subject, input.actor);
+    const sameDay = asTrimmedString(existingClaims[VitalSignDayBatchClaim.Day]) === day;
+    const existingBatchId = asTrimmedString(baseBundle.id || existingClaims[VitalSignDayBatchClaim.Identifier]);
+    const reused = Boolean(existingBatchId && sameOwner && sameDay && (dayEntryIds.length > 0 || matchingDayEntry));
+    const batchId = reused ? existingBatchId : createCanonicalIdentifierUrn();
+    const bundle = {
+        ...baseBundle,
+        id: batchId,
+        meta: {
+            ...(baseBundle.meta || {}),
+            claims: {
+                ...existingClaims,
+                ...buildVitalSignDayBatchClaims(input),
+                [VitalSignDayBatchClaim.Identifier]: batchId,
+            },
+        },
+        data: [...(baseBundle.data || [])],
+    };
+    if (input.entry) {
+        bundle.data.push(cloneEntry(input.entry));
+    }
+    return {
+        batchId,
+        day,
+        reused,
+        bundle,
+    };
+}
+export function openOrCreateVitalSignDayBatchBundle(input) {
+    return resolveVitalSignDayBatchId(input).bundle;
+}
+function matchesBatchOwner(entry, subject, actor) {
+    const claims = asRecord(entry.resource?.meta?.claims || entry.meta?.claims);
+    return matchesBatchOwnerClaims(claims, subject, actor);
+}
+function matchesBatchOwnerClaims(claims, subject, actor) {
+    return asTrimmedString(claims[VitalSignDayBatchClaim.Subject]) === asTrimmedString(subject)
+        && asTrimmedString(claims[VitalSignDayBatchClaim.Actor]) === asTrimmedString(actor);
+}
+function resolveDayKey(value) {
+    if (value instanceof Date) {
+        return value.toISOString().slice(0, 10);
+    }
+    const raw = asTrimmedString(value);
+    if (!raw) {
+        return new Date().toISOString().slice(0, 10);
+    }
+    const parsed = Date.parse(raw);
+    if (Number.isNaN(parsed)) {
+        return raw.slice(0, 10);
+    }
+    return new Date(parsed).toISOString().slice(0, 10);
+}
+function resolveDayRange(day) {
+    return {
+        from: `${day}T00:00:00.000Z`,
+        to: `${day}T23:59:59.999Z`,
+    };
+}
+function asTrimmedString(value) {
+    if (value === undefined || value === null) {
+        return '';
+    }
+    return String(value).trim();
+}
+function asRecord(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return {};
+    }
+    return value;
+}
+function cloneBundle(bundle) {
+    return JSON.parse(JSON.stringify(bundle));
+}
+function cloneEntry(entry) {
+    return JSON.parse(JSON.stringify(entry));
+}
+function createEmptyBundle() {
+    return {
+        resourceType: 'Bundle',
+        type: 'collection',
+        data: [],
+    };
+}

package/dist/utils/vital-sign-entry-editor.d.ts

@@ -0,0 +1,61 @@
+/**
+ * File discipline note:
+ * - Read `ARCHITECTURE.md` and `CONTRIBUTING.md` before changing this module.
+ * - Keep exactly one exported class per file.
+ * - Keep this file focused on one typed editor surface.
+ * - Move shared helpers to reusable helper/base modules instead of duplicating logic here.
+ */
+import { type CodingDescriptor } from '../constants/vital-signs';
+import { ObservationComponentEntryEditor } from './observation-component-entry-editor';
+/**
+ * Typed editor for one staged VitalSign resource entry.
+ *
+ * Use this surface when the frontend needs a simple authoring path for common
+ * measurements such as heart rate, temperature, or blood pressure.
+ */
+export declare class VitalSignEntryEditor extends ObservationComponentEntryEditor {
+    /** Overrides the canonical identifier when import or migration logic needs one explicit public id. */
+    setIdentifier(identifier?: string | null): this;
+    /** Returns the canonical identifier currently exposed for this vital-sign entry. */
+    getIdentifier(): string | undefined;
+    /** Ensures the entry has one synchronized canonical identifier across public claim, `resource.id`, and `fullUrl`. */
+    ensureIdentifier(): string;
+    /** Sets the subject/patient reference for this vital-sign observation. */
+    setSubject(subject: string): this;
+    /** Returns the subject/patient reference for this vital-sign observation. */
+    getSubject(): string | undefined;
+    /** Sets the observation status. */
+    setStatus(status: string): this;
+    /** Returns the observation status. */
+    getStatus(): string | undefined;
+    /** Sets the observation category, usually one of the shared vital-sign category descriptors. */
+    setCategory(category: CodingDescriptor | string): this;
+    /** Returns the observation category token. */
+    getCategory(): string | undefined;
+    /** Sets the observation date/effective time. */
+    setDate(date: string): this;
+    /** Returns the observation date/effective time. */
+    getDate(): string | undefined;
+    /** Sets one free-text note for the vital sign. */
+    setNote(note: string): this;
+    /** Returns the free-text note for the vital sign. */
+    getNote(): string | undefined;
+    /** Seeds the observation code and optional quantity unit for the selected vital-sign family. */
+    setVitalSignType(code: CodingDescriptor, unit?: CodingDescriptor): this;
+    /** Convenience helper for heart-rate authoring using the shared code/unit catalog. */
+    setHeartRate(value: number): this;
+    /** Returns the heart-rate numeric value. */
+    getHeartRate(): number | undefined;
+    /** Convenience helper for body-temperature authoring using the shared code/unit catalog. */
+    setBodyTemperature(value: number): this;
+    /** Returns the body-temperature numeric value. */
+    getBodyTemperature(): number | undefined;
+    /** Convenience helper for systolic blood-pressure authoring. */
+    setSystolicBloodPressure(value: number): this;
+    /** Returns the systolic blood-pressure numeric value. */
+    getSystolicBloodPressure(): number | undefined;
+    /** Convenience helper for diastolic blood-pressure authoring. */
+    setDiastolicBloodPressure(value: number): this;
+    /** Returns the diastolic blood-pressure numeric value. */
+    getDiastolicBloodPressure(): number | undefined;
+}

package/dist/utils/vital-sign-entry-editor.js

@@ -0,0 +1,152 @@
+/**
+ * File discipline note:
+ * - Read `ARCHITECTURE.md` and `CONTRIBUTING.md` before changing this module.
+ * - Keep exactly one exported class per file.
+ * - Keep this file focused on one typed editor surface.
+ * - Move shared helpers to reusable helper/base modules instead of duplicating logic here.
+ */
+import { ObservationCategoryCodes, VitalSignsCodes, VitalSignsUnits } from '../constants/vital-signs.js';
+import { ObservationClaim } from '../models/interoperable-claims/observation-claims.js';
+import { BundleEditableResourceTypes } from '../models/bundle-editor-types.js';
+import { createCanonicalIdentifierUrn, normalizeOptionalIdentifier } from './bundle-editor-helpers.js';
+import { ObservationComponentEntryEditor } from './observation-component-entry-editor.js';
+import { registerBundleEntryEditor } from './bundle-editor-registry.js';
+/**
+ * Typed editor for one staged VitalSign resource entry.
+ *
+ * Use this surface when the frontend needs a simple authoring path for common
+ * measurements such as heart rate, temperature, or blood pressure.
+ */
+export class VitalSignEntryEditor extends ObservationComponentEntryEditor {
+    /** Overrides the canonical identifier when import or migration logic needs one explicit public id. */
+    setIdentifier(identifier) {
+        const normalized = normalizeOptionalIdentifier(identifier);
+        if (!normalized) {
+            this.removeClaim(ObservationClaim.Identifier);
+            this.setResourceId(undefined);
+            this.setFullUrl(undefined);
+            return this;
+        }
+        this.setClaim(ObservationClaim.Identifier, normalized);
+        this.setResourceId(normalized);
+        this.setFullUrl(normalized);
+        return this;
+    }
+    /** Returns the canonical identifier currently exposed for this vital-sign entry. */
+    getIdentifier() {
+        return normalizeOptionalIdentifier(this.getClaim(ObservationClaim.Identifier)
+            || this.getResourceId()
+            || this.getFullUrl());
+    }
+    /** Ensures the entry has one synchronized canonical identifier across public claim, `resource.id`, and `fullUrl`. */
+    ensureIdentifier() {
+        const existing = this.getIdentifier();
+        if (existing)
+            return existing;
+        const generated = createCanonicalIdentifierUrn();
+        this.setIdentifier(generated);
+        return generated;
+    }
+    /** Sets the subject/patient reference for this vital-sign observation. */
+    setSubject(subject) {
+        const normalized = String(subject).trim();
+        this.setClaim(ObservationClaim.Subject, normalized);
+        this.setClaim(ObservationClaim.Patient, normalized);
+        return this;
+    }
+    /** Returns the subject/patient reference for this vital-sign observation. */
+    getSubject() {
+        return normalizeOptionalIdentifier(this.getClaim(ObservationClaim.Subject)
+            || this.getClaim(ObservationClaim.Patient));
+    }
+    /** Sets the observation status. */
+    setStatus(status) {
+        return this.setClaim(ObservationClaim.Status, String(status).trim());
+    }
+    /** Returns the observation status. */
+    getStatus() {
+        return normalizeOptionalIdentifier(this.getClaim(ObservationClaim.Status));
+    }
+    /** Sets the observation category, usually one of the shared vital-sign category descriptors. */
+    setCategory(category) {
+        const normalized = typeof category === 'string' ? category.trim() : category.claim;
+        return this.setClaim(ObservationClaim.Category, normalized);
+    }
+    /** Returns the observation category token. */
+    getCategory() {
+        return normalizeOptionalIdentifier(this.getClaim(ObservationClaim.Category));
+    }
+    /** Sets the observation date/effective time. */
+    setDate(date) {
+        const normalized = String(date).trim();
+        this.setClaim(ObservationClaim.Date, normalized);
+        this.setClaim(ObservationClaim.EffectiveDateTime, normalized);
+        return this;
+    }
+    /** Returns the observation date/effective time. */
+    getDate() {
+        return normalizeOptionalIdentifier(this.getClaim(ObservationClaim.Date)
+            || this.getClaim(ObservationClaim.EffectiveDateTime));
+    }
+    /** Sets one free-text note for the vital sign. */
+    setNote(note) {
+        return this.setClaim(ObservationClaim.Note, String(note).trim());
+    }
+    /** Returns the free-text note for the vital sign. */
+    getNote() {
+        return normalizeOptionalIdentifier(this.getClaim(ObservationClaim.Note));
+    }
+    /** Seeds the observation code and optional quantity unit for the selected vital-sign family. */
+    setVitalSignType(code, unit) {
+        this.setCategory(ObservationCategoryCodes.VitalSigns);
+        this.setStatus(this.getStatus() || 'final');
+        this.setCode(code);
+        this.setCodeSystem(code.system);
+        this.setCodeValue(code.code);
+        if (code.display) {
+            this.setCodeDisplay(code.display);
+            this.setCodeTextLocal(code.display);
+        }
+        if (unit) {
+            this.setValueQuantityUnit(unit);
+        }
+        return this;
+    }
+    /** Convenience helper for heart-rate authoring using the shared code/unit catalog. */
+    setHeartRate(value) {
+        this.setVitalSignType(VitalSignsCodes.HeartRate, VitalSignsUnits.BeatsPerMinute);
+        return this.setValueQuantityNumber(value);
+    }
+    /** Returns the heart-rate numeric value. */
+    getHeartRate() {
+        return this.getValueQuantityNumber();
+    }
+    /** Convenience helper for body-temperature authoring using the shared code/unit catalog. */
+    setBodyTemperature(value) {
+        this.setVitalSignType(VitalSignsCodes.BodyTemperature, VitalSignsUnits.Celsius);
+        return this.setValueQuantityNumber(value);
+    }
+    /** Returns the body-temperature numeric value. */
+    getBodyTemperature() {
+        return this.getValueQuantityNumber();
+    }
+    /** Convenience helper for systolic blood-pressure authoring. */
+    setSystolicBloodPressure(value) {
+        this.setVitalSignType(VitalSignsCodes.SystolicBloodPressure, VitalSignsUnits.MillimeterOfMercury);
+        return this.setValueQuantityNumber(value);
+    }
+    /** Returns the systolic blood-pressure numeric value. */
+    getSystolicBloodPressure() {
+        return this.getValueQuantityNumber();
+    }
+    /** Convenience helper for diastolic blood-pressure authoring. */
+    setDiastolicBloodPressure(value) {
+        this.setVitalSignType(VitalSignsCodes.DiastolicBloodPressure, VitalSignsUnits.MillimeterOfMercury);
+        return this.setValueQuantityNumber(value);
+    }
+    /** Returns the diastolic blood-pressure numeric value. */
+    getDiastolicBloodPressure() {
+        return this.getValueQuantityNumber();
+    }
+}
+registerBundleEntryEditor(BundleEditableResourceTypes.vitalSign, VitalSignEntryEditor);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdc-common-utils-ts",
-  "version": "2.1.0",
+  "version": "2.3.0",
   "publishConfig": {
     "access": "public"
   },
@@ -11,6 +11,7 @@
     "@stablelib/utf8": "^1.0.2",
     "base-x": "^4.0.0",
     "gdc-common-utils-ts": "^2.0.1",
+    "jose": "^4.15.9",
     "pako": "^2.1.0"
   },
   "scripts": {