@medplum/core 0.9.12 → 0.9.13

package/dist/cjs/index.js

@@ -572,6 +572,165 @@
     function isLowerCase(c) {
         return c === c.toLowerCase();
     }
+    /**
+     * Tries to find a code string for a given system within a given codeable concept.
+     * @param concept The codeable concept.
+     * @param system The system string.
+     * @returns The code if found; otherwise undefined.
+     */
+    function getCodeBySystem(concept, system) {
+        var _a, _b;
+        return (_b = (_a = concept === null || concept === void 0 ? void 0 : concept.coding) === null || _a === void 0 ? void 0 : _a.find((coding) => coding.system === system)) === null || _b === void 0 ? void 0 : _b.code;
+    }
+    /**
+     * Sets a code for a given system within a given codeable concept.
+     * @param concept The codeable concept.
+     * @param system The system string.
+     * @param code The code value.
+     */
+    function setCodeBySystem(concept, system, code) {
+        var _a, _b;
+        if (!concept.coding) {
+            concept.coding = [];
+        }
+        const coding = (_a = concept.coding) === null || _a === void 0 ? void 0 : _a.find((c) => c.system === system);
+        if (coding) {
+            coding.code = code;
+        }
+        else {
+            (_b = concept.coding) === null || _b === void 0 ? void 0 : _b.push({ system, code });
+        }
+    }
+    /**
+     * Tries to find an observation interval for the given patient and value.
+     * @param definition The observation definition.
+     * @param patient The patient.
+     * @param value The observation value.
+     * @returns The observation interval if found; otherwise undefined.
+     */
+    function findObservationInterval(definition, patient, value, category) {
+        var _a;
+        return (_a = definition.qualifiedInterval) === null || _a === void 0 ? void 0 : _a.find((interval) => {
+            var _a;
+            return observationIntervalMatchesPatient(interval, patient) &&
+                observationIntervalMatchesValue(interval, value, (_a = definition.quantitativeDetails) === null || _a === void 0 ? void 0 : _a.decimalPrecision) &&
+                (category === undefined || interval.category === category);
+        });
+    }
+    /**
+     * Returns true if the patient matches the observation interval.
+     * @param interval The observation interval.
+     * @param patient The patient.
+     * @returns True if the patient matches the observation interval.
+     */
+    function observationIntervalMatchesPatient(interval, patient) {
+        return observationIntervalMatchesGender(interval, patient) && observationIntervalMatchesAge(interval, patient);
+    }
+    /**
+     * Returns true if the patient gender matches the observation interval.
+     * @param interval The observation interval.
+     * @param patient The patient.
+     * @returns True if the patient gender matches the observation interval.
+     */
+    function observationIntervalMatchesGender(interval, patient) {
+        return !interval.gender || interval.gender === patient.gender;
+    }
+    /**
+     * Returns true if the patient age matches the observation interval.
+     * @param interval The observation interval.
+     * @param patient The patient.
+     * @returns True if the patient age matches the observation interval.
+     */
+    function observationIntervalMatchesAge(interval, patient) {
+        return !interval.age || matchesRange(calculateAge(patient.birthDate).years, interval.age);
+    }
+    /**
+     * Returns true if the value matches the observation interval.
+     * @param interval The observation interval.
+     * @param value The observation value.
+     * @param precision Optional precision in number of digits.
+     * @returns True if the value matches the observation interval.
+     */
+    function observationIntervalMatchesValue(interval, value, precision) {
+        return !!interval.range && matchesRange(value, interval.range, precision);
+    }
+    /**
+     * Returns true if the value is in the range accounting for precision.
+     * @param value The numeric value.
+     * @param range The numeric range.
+     * @param precision Optional precision in number of digits.
+     * @returns True if the value is within the range.
+     */
+    function matchesRange(value, range, precision) {
+        var _a, _b;
+        return ((((_a = range.low) === null || _a === void 0 ? void 0 : _a.value) === undefined || preciseGreaterThanOrEquals(value, range.low.value, precision)) &&
+            (((_b = range.high) === null || _b === void 0 ? void 0 : _b.value) === undefined || preciseLessThanOrEquals(value, range.high.value, precision)));
+    }
+    /**
+     * Returns true if the two numbers are equal to the given precision.
+     * @param a The first number.
+     * @param b The second number.
+     * @param precision Optional precision in number of digits.
+     * @returns True if the two numbers are equal to the given precision.
+     */
+    function preciseEquals(a, b, precision) {
+        if (precision) {
+            return Math.abs(a - b) < Math.pow(10, -precision);
+        }
+        else {
+            return a === b;
+        }
+    }
+    /**
+     * Returns true if the first number is less than the second number to the given precision.
+     * @param a The first number.
+     * @param b The second number.
+     * @param precision Optional precision in number of digits.
+     * @returns True if the first number is less than the second number to the given precision.
+     */
+    function preciseLessThan(a, b, precision) {
+        if (precision) {
+            return a < b && Math.abs(a - b) > Math.pow(10, -precision);
+        }
+        else {
+            return a < b;
+        }
+    }
+    /**
+     * Returns true if the first number is greater than the second number to the given precision.
+     * @param a The first number.
+     * @param b The second number.
+     * @param precision Optional precision in number of digits.
+     * @returns True if the first number is greater than the second number to the given precision.
+     */
+    function preciseGreaterThan(a, b, precision) {
+        if (precision) {
+            return a > b && Math.abs(a - b) > Math.pow(10, -precision);
+        }
+        else {
+            return a > b;
+        }
+    }
+    /**
+     * Returns true if the first number is less than or equal to the second number to the given precision.
+     * @param a The first number.
+     * @param b The second number.
+     * @param precision Optional precision in number of digits.
+     * @returns True if the first number is less than or equal to the second number to the given precision.
+     */
+    function preciseLessThanOrEquals(a, b, precision) {
+        return preciseLessThan(a, b, precision) || preciseEquals(a, b, precision);
+    }
+    /**
+     * Returns true if the first number is greater than or equal to the second number to the given precision.
+     * @param a The first number.
+     * @param b The second number.
+     * @param precision Optional precision in number of digits.
+     * @returns True if the first number is greater than or equal to the second number to the given precision.
+     */
+    function preciseGreaterThanOrEquals(a, b, precision) {
+        return preciseGreaterThan(a, b, precision) || preciseEquals(a, b, precision);
+    }
 
     /**
      * Returns a cryptographically secure random string.
@@ -1651,7 +1810,13 @@
          */
         getCachedReference(reference) {
             const refString = reference.reference;
+            if (!refString) {
+                return undefined;
+            }
             const [resourceType, id] = refString.split('/');
+            if (!resourceType || !id) {
+                return undefined;
+            }
             return this.getCached(resourceType, id);
         }
         /**
@@ -1697,6 +1862,9 @@
                 return new ReadablePromise(Promise.reject(new Error('Missing reference')));
             }
             const [resourceType, id] = refString.split('/');
+            if (!resourceType || !id) {
+                return new ReadablePromise(Promise.reject(new Error('Invalid reference')));
+            }
             return this.readResource(resourceType, id);
         }
         /**
@@ -5382,11 +5550,13 @@
     exports.created = created;
     exports.deepEquals = deepEquals$1;
     exports.evalFhirPath = evalFhirPath;
+    exports.findObservationInterval = findObservationInterval;
     exports.formatAddress = formatAddress;
     exports.formatFamilyName = formatFamilyName;
     exports.formatGivenName = formatGivenName;
     exports.formatHumanName = formatHumanName;
     exports.formatSearchQuery = formatSearchQuery;
+    exports.getCodeBySystem = getCodeBySystem;
     exports.getDateProperty = getDateProperty;
     exports.getDisplayString = getDisplayString;
     exports.getExpressionForResourceType = getExpressionForResourceType;
@@ -5409,11 +5579,18 @@
     exports.isProfileResource = isProfileResource;
     exports.isStringArray = isStringArray;
     exports.isUUID = isUUID;
+    exports.matchesRange = matchesRange;
     exports.notFound = notFound;
     exports.notModified = notModified;
     exports.parseFhirPath = parseFhirPath;
     exports.parseSearchDefinition = parseSearchDefinition;
+    exports.preciseEquals = preciseEquals;
+    exports.preciseGreaterThan = preciseGreaterThan;
+    exports.preciseGreaterThanOrEquals = preciseGreaterThanOrEquals;
+    exports.preciseLessThan = preciseLessThan;
+    exports.preciseLessThanOrEquals = preciseLessThanOrEquals;
     exports.resolveId = resolveId;
+    exports.setCodeBySystem = setCodeBySystem;
     exports.stringify = stringify;
     exports.tokenize = tokenize;