fhir-dosage-utils 1.1.0 → 1.2.0

package/dist/main.js

@@ -72,43 +72,77 @@ function $5ab57a471c359130$export$7de3722258b87db9({ config: config, dos: dos, i
 }
 
 
-// types
-function $9a073aa5b09aa778$export$4cd16590995531a9({ dos: dos, config: config, i18next: i18next }) {
-    // If empty, return undefined
-    if (dos.doseAndRate === undefined) return undefined;
-    // Find the first entry that match criteria
-    let doseRange = dos.doseAndRate.find((s)=>s.doseRange !== undefined);
-    // If not found, skip
-    if (doseRange === undefined) return undefined;
-    let low = doseRange.doseRange.low?.value;
-    let high = doseRange.doseRange.high?.value;
-    let quantityUnit = doseRange.doseRange.high !== undefined ? doseRange.doseRange.high : doseRange.doseRange.low;
-    // quantity unit
-    let unit = config.fromFHIRQuantityUnitToString({
+// Utility function
+// Quantity unit to string
+function $9ee880701f47723b$var$transformQuantityUnitToString(i18next, quantity, config) {
+    let quantityValue = quantity.value;
+    // If common units from HL7, do the job
+    if (quantity.system === "http://hl7.org/fhir/ValueSet/duration-units") {
+        let code = quantity.code;
+        return i18next.t(`unitsOfTime:withoutCount.${code}`, {
+            count: quantityValue
+        });
+    } else // otherwise, it is UCUM, ... so let the user do the job
+    return config.fromFHIRQuantityUnitToString({
         language: config.language,
-        quantity: quantityUnit
+        quantity: quantity
     });
-    // Three cases
-    // 1. Both low & high are present
-    if (high !== undefined && low !== undefined) return i18next.t("fields.doseRange.lowAndHigh", {
-        low: low,
-        high: high,
+}
+function $9ee880701f47723b$export$be17d167ed50d870({ range: range, config: config, i18next: i18next }) {
+    // Extract params
+    const { low: low, high: high } = range;
+    const lowValue = low?.value;
+    const highValue = high?.value;
+    // prepare unit display
+    let quantityUnit = high || low;
+    let hasUnit = quantityUnit?.unit !== undefined || quantityUnit?.code !== undefined;
+    // Four cases
+    // 1. If we have a empty object, return undefined
+    if (lowValue === undefined && highValue === undefined) return undefined;
+    // quantity unit
+    let unit = hasUnit ? $9ee880701f47723b$var$transformQuantityUnitToString(i18next, quantityUnit, config) : "";
+    let technicalKey = hasUnit ? "withUnit" : "withoutUnit";
+    // 2. Both low & high are present
+    if (lowValue !== undefined && highValue !== undefined) return i18next.t(`amount.range.${technicalKey}.lowAndHigh`, {
+        low: lowValue,
+        high: highValue,
         unit: unit
     });
-    // 2. Only high is present
-    if (high !== undefined) return i18next.t("fields.doseRange.onlyHigh", {
-        high: high,
+    // 3. Only high is present
+    if (highValue !== undefined) return i18next.t(`amount.range.${technicalKey}.onlyHigh`, {
+        high: highValue,
         unit: unit
     });
-    // 3. Only low is present
+    // 4. Only low is present
     // Warning, this case is kind dangerous and clinically unsafe so minimal effort on this ...
-    return i18next.t("fields.doseRange.onlyLow", {
-        low: low,
+    return i18next.t(`amount.range.${technicalKey}.onlyLow`, {
+        low: lowValue,
         unit: unit
     });
 }
 
 
+function $9a073aa5b09aa778$export$4cd16590995531a9({ dos: dos, config: config, i18next: i18next }) {
+    // If empty, return undefined
+    if (dos.doseAndRate === undefined) return undefined;
+    // Find the first entry that match criteria
+    let doseRange = dos.doseAndRate.find((s)=>s.doseRange !== undefined);
+    // If not found, skip
+    if (doseRange === undefined) return undefined;
+    // Turn range into a text
+    const text = (0, $9ee880701f47723b$export$be17d167ed50d870)({
+        range: doseRange.doseRange,
+        config: config,
+        i18next: i18next
+    });
+    // Reject if empty
+    if (text === undefined) return undefined;
+    return i18next.t("fields.doseRange", {
+        rangeText: text
+    });
+}
+
+
 // types
 function $052c79abb28cba29$export$4e24ef8c7997cc56({ dos: dos, config: config, i18next: i18next }) {
     // If empty, return undefined
@@ -131,72 +165,91 @@ function $052c79abb28cba29$export$4e24ef8c7997cc56({ dos: dos, config: config, i
 }
 
 
-// types
+// Utility function
+
 function $703b645b55481398$export$d3dd7d3522271dba({ dos: dos, config: config, i18next: i18next }) {
     // If empty, return undefined
     if (dos.doseAndRate === undefined) return undefined;
     // Find the first entry that match criteria
-    let rateRange = dos.doseAndRate.find((s)=>s.rateRange !== undefined);
+    let doseAndRate = dos.doseAndRate.find((s)=>s.rateRange !== undefined);
     // If not found, skip
-    if (rateRange === undefined) return undefined;
-    // low / high
-    let low = rateRange.rateRange.low;
-    let high = rateRange.rateRange.high;
-    let quantityLow = low?.value;
-    let quantityHigh = high?.value;
-    // quantity unit
-    let unit = config.fromFHIRQuantityUnitToString({
-        language: config.language,
-        quantity: high || low
+    if (doseAndRate === undefined) return undefined;
+    // Turn range into a text
+    const rangeText = (0, $9ee880701f47723b$export$be17d167ed50d870)({
+        range: doseAndRate.rateRange,
+        config: config,
+        i18next: i18next
     });
-    // Three cases
-    // 1. Both low & high are present
-    if (quantityHigh !== undefined && quantityLow !== undefined) return i18next.t("fields.rateRange.lowAndHigh", {
-        low: quantityLow,
-        high: quantityHigh,
-        unit: unit
-    });
-    // 2. Only high is present
-    if (quantityHigh !== undefined) return i18next.t("fields.rateRange.onlyHigh", {
-        high: quantityHigh,
-        unit: unit
-    });
-    // 3. Only low is present
-    // Warning, this case is kind dangerous and clinically unsafe so minimal effort on this ...
-    return i18next.t("fields.rateRange.onlyLow", {
-        low: quantityLow,
-        unit: unit
+    // Reject if empty
+    if (rangeText === undefined) return undefined;
+    // return the final string
+    return i18next.t("fields.rateRange", {
+        rangeText: rangeText
     });
 }
 
 
-// types
-function $301791f33da707fa$export$b71cfd2510242de2({ dos: dos, config: config, i18next: i18next }) {
-    // If empty, return undefined
-    if (dos.doseAndRate === undefined) return undefined;
-    // Find the first entry that match criteria
-    let rateRatio = dos.doseAndRate.find((s)=>s.rateRatio !== undefined);
-    // If not found, skip
-    if (rateRatio === undefined) return undefined;
-    // num / dem
-    let numerator = rateRatio.rateRatio.numerator;
-    let denominator = rateRatio.rateRatio.denominator;
-    let quantityNum = numerator?.value || 1;
-    let quantityDenom = denominator?.value || 1;
+// Quantity has an unit ?
+function $7895e9944cc835ce$var$hasUnit(quantity) {
+    return (quantity?.unit || quantity?.code) !== undefined;
+}
+function $7895e9944cc835ce$export$fdc6e9cbd31555fb({ ratio: ratio, config: config, i18next: i18next }) {
+    // Extract params
+    const { denominator: denominator, numerator: numerator } = ratio;
     // units as text
-    let numeratorUnit = numerator !== undefined ? config.fromFHIRQuantityUnitToString({
+    let numeratorUnit = $7895e9944cc835ce$var$hasUnit(numerator) ? config.fromFHIRQuantityUnitToString({
         language: config.language,
         quantity: numerator
-    }) : "";
-    let denominatorUnit = denominator !== undefined ? config.fromFHIRQuantityUnitToString({
+    }) : undefined;
+    let denominatorUnit = $7895e9944cc835ce$var$hasUnit(denominator) ? config.fromFHIRQuantityUnitToString({
         language: config.language,
         quantity: denominator
-    }) : "";
-    return i18next.t("fields.rateRatio.rateRatio", {
-        count: quantityDenom,
-        quantityNumerator: quantityNum,
-        numeratorUnit: numeratorUnit,
-        denominatorUnit: denominatorUnit
+    }) : undefined;
+    // quantity
+    let quantityNumerator = numerator?.value;
+    let quantityDenominator = denominator?.value;
+    // Collect
+    const parts = [];
+    // Deal with numerator first
+    if (quantityNumerator !== undefined) {
+        let technicalKey = numeratorUnit !== undefined ? "withUnit" : "withoutUnit";
+        const numeratorString = i18next.t(`amount.ratio.${technicalKey}.numerator`, {
+            count: quantityNumerator,
+            numeratorUnit: numeratorUnit
+        });
+        parts.push(numeratorString);
+    }
+    // Deal with denominator
+    if (quantityDenominator !== undefined) {
+        let technicalKey = denominatorUnit !== undefined ? "withUnit" : "withoutUnit";
+        const denominatorString = i18next.t(`amount.ratio.${technicalKey}.denominator`, {
+            count: quantityDenominator,
+            denominatorUnit: denominatorUnit
+        });
+        parts.push(denominatorString);
+    }
+    // Concatenate the result
+    if (parts.length === 0) return undefined;
+    else return parts.join(" ");
+}
+
+
+function $301791f33da707fa$export$b71cfd2510242de2({ dos: dos, config: config, i18next: i18next }) {
+    // If empty, return undefined
+    if (dos.doseAndRate === undefined) return undefined;
+    // Find the first entry that match criteria
+    let doseAndRate = dos.doseAndRate.find((s)=>s.rateRatio !== undefined);
+    // If not found, skip
+    if (doseAndRate === undefined) return undefined;
+    // Turn ratio to text
+    const ratioText = (0, $7895e9944cc835ce$export$fdc6e9cbd31555fb)({
+        config: config,
+        i18next: i18next,
+        ratio: doseAndRate.rateRatio
+    });
+    if (ratioText === undefined) return undefined;
+    return i18next.t("fields.rateRatio", {
+        ratioText: ratioText
     });
 }
 
@@ -496,21 +549,7 @@ function $9d632517596957df$export$b927a06bc51aea32({ dos: dos, config: config, i
 
 
 // types
-// Quantity unit to string
-function $2da391a8a8345a3d$var$transformQuantityUnitToString(i18next, quantity, config) {
-    let quantityValue = quantity.value;
-    // If common units from HL7, do the job
-    if (quantity.system === "http://hl7.org/fhir/ValueSet/duration-units") {
-        let code = quantity.code;
-        return i18next.t(`unitsOfTime:withoutCount.${code}`, {
-            count: quantityValue
-        });
-    } else // otherwise, it is UCUM, ... so let the user do the job
-    return config.fromFHIRQuantityUnitToString({
-        language: config.language,
-        quantity: quantity
-    });
-}
+
 function $2da391a8a8345a3d$export$8c667cbf7bebaa93({ dos: dos, config: config, i18next: i18next }) {
     // If empty, return undefined
     if (dos.timing === undefined || dos.timing.repeat === undefined) return undefined;
@@ -520,26 +559,17 @@ function $2da391a8a8345a3d$export$8c667cbf7bebaa93({ dos: dos, config: config, i
     // Do nothing if no boundsRange, I am not a wizard
     if (boundsRange === undefined) return undefined;
     else {
-        let low = boundsRange.low;
-        let high = boundsRange.high;
-        // quantity unit
-        let unit = $2da391a8a8345a3d$var$transformQuantityUnitToString(i18next, high || low, config);
-        // Three cases
-        // 1. Both low & high are present
-        if (high !== undefined && low !== undefined) return i18next.t("fields.boundsRange.lowAndHigh", {
-            low: low.value,
-            high: high.value,
-            unit: unit
-        });
-        // 2. Only high is present
-        if (high !== undefined) return i18next.t("fields.boundsRange.onlyHigh", {
-            high: high.value,
-            unit: unit
+        // Turn range into a text
+        const rangeText = (0, $9ee880701f47723b$export$be17d167ed50d870)({
+            range: boundsRange,
+            config: config,
+            i18next: i18next
         });
-        // 3. Only low is present
-        return i18next.t("fields.boundsRange.onlyLow", {
-            low: low.value,
-            unit: unit
+        // Reject if empty
+        if (rangeText === undefined) return undefined;
+        // return the final string
+        return i18next.t("fields.boundsRange", {
+            rangeText: rangeText
         });
     }
 }
@@ -764,6 +794,7 @@ function $45256d2a188dcbd7$export$75a89431d80a701a({ dos: dos, config: config, i
 
 
 
+
 function $39ffdeadc450f558$export$346b11a8cb220f02({ dos: dos, config: config, i18next: i18next }) {
     // If empty, return undefined
     if (dos.maxDosePerPeriod === undefined) return undefined;
@@ -778,29 +809,14 @@ function $39ffdeadc450f558$export$346b11a8cb220f02({ dos: dos, config: config, i
     if (values.length === 0) return undefined;
     // Periods are expressed as ratio (like rateRatio)
     const valuesAsString = values.map((period)=>{
-        // num / dem
-        let numerator = period.numerator;
-        let denominator = period.denominator;
-        let quantityNum = numerator?.value || 1;
-        let quantityDenom = denominator?.value || 1;
-        // units as text
-        let numeratorUnit = numerator !== undefined ? config.fromFHIRQuantityUnitToString({
-            language: config.language,
-            quantity: numerator
-        }) : "";
-        let denominatorUnit = denominator !== undefined ? config.fromFHIRQuantityUnitToString({
-            language: config.language,
-            quantity: denominator
-        }) : "";
-        return i18next.t("fields.maxDosePerPeriod.maxDosePerPeriod", {
-            count: quantityDenom,
-            quantityNumerator: quantityNum,
-            numeratorUnit: numeratorUnit,
-            denominatorUnit: denominatorUnit
+        return (0, $7895e9944cc835ce$export$fdc6e9cbd31555fb)({
+            config: config,
+            i18next: i18next,
+            ratio: period
         });
-    });
+    }).filter((s)=>s !== undefined);
     const maxDosePerPeriodText = (0, $93b58b7d2ead3b95$export$826742c1df3eca39)(i18next, valuesAsString);
-    return i18next.t("fields.maxDosePerPeriod.general", {
+    return i18next.t("fields.maxDosePerPeriod", {
         count: values.length,
         maxDosePerPeriodText: maxDosePerPeriodText
     });
@@ -1020,9 +1036,8 @@ class $74b0cf9d3dbd5b46$export$1c191bca55f84a03 {
         return this.getFields(dos, ...order);
     }
     /**
-   * Turn multiple FHIR Dosage object into text
-   */ fromMultipleDosageToText(dosages) {
-        // As we can have concurrent / sequential instructions, we need a generic algorithm to do the job
+   * Does this array of Dosage objects contains only "sequential" instructions ?
+   */ containsOnlySequentialInstructions(dosages) {
         // 1. Collect all sequences number
         let sequencesNumbers = dosages.map((d)=>d.sequence).filter((s)=>s !== undefined);
         // 2. Convert it to a Set
@@ -1030,11 +1045,13 @@ class $74b0cf9d3dbd5b46$export$1c191bca55f84a03 {
         // 3. We have a "sequential" situation in two cases
         // A) No sequence number were provided
         // B) All sequence numbers are different
-        if (encounteredSequenceNumbers.size === 0 || encounteredSequenceNumbers.size === dosages.length) {
-            const dosagesAsText = dosages.map((d)=>this.fromDosageToText(d));
-            return (0, $93b58b7d2ead3b95$export$826742c1df3eca39)(this.i18nInstance, dosagesAsText, "then");
-        }
-        // 4. We have both "sequential" and "concurrent" instructions - time to see what is the configuration
+        return encounteredSequenceNumbers.size === 0 || encounteredSequenceNumbers.size === dosages.length;
+    }
+    /**
+   * Turn this array of Dosage objects into a data structure useful to handle "sequential" and "concurrent" instructions (cf. "sequence" property).
+   * @returns {Dosage[][]} - A two-dimensional array where each inner array contains Dosage objects belonging to the same sequence numberr.
+   */ groupBySequence(dosages) {
+        // Prepare variables
         let groups = {};
         let sequences = new Set();
         for(let idx = 0; idx < dosages.length; idx++){
@@ -1043,23 +1060,39 @@ class $74b0cf9d3dbd5b46$export$1c191bca55f84a03 {
             // Get the sequence number (normally, in real world, it should be present in this case)
             // If no sequence number, assume it is idx + 1
             let sequenceNr = dosage.sequence || idx + 1;
-            // Generate the text version
-            let dosageAsText = this.fromDosageToText(dosage);
             // Retrieve of create previous entries for this sequence number
             let localGroup = groups[sequenceNr] || [];
             // Add entry
-            localGroup.push(dosageAsText);
+            localGroup.push(dosage);
             // Pushback result
             groups[sequenceNr] = localGroup;
             // For reminder of the parsed sequence
             sequences.add(sequenceNr);
         }
-        // 5. Now that data structures are filled, it is a piece of cake to generate the result
-        let sequentialInstructions = [
+        // By using the Set values, we are sure it is returned in the way Dosages were written
+        return [
             ...sequences.values()
         ].map((sequence)=>{
             let concurrentInstructions = groups[sequence];
-            return (0, $93b58b7d2ead3b95$export$826742c1df3eca39)(this.i18nInstance, concurrentInstructions, "and");
+            return concurrentInstructions;
+        });
+    }
+    /**
+   * Turn multiple FHIR Dosage objects into text
+   */ fromMultipleDosageToText(dosages) {
+        // As we can have concurrent / sequential instructions, we need a generic algorithm to do the job
+        const hasOnlySequentialInstructions = this.containsOnlySequentialInstructions(dosages);
+        // Sequential instructions
+        if (hasOnlySequentialInstructions) {
+            const dosagesAsText = dosages.map((d)=>this.fromDosageToText(d));
+            return (0, $93b58b7d2ead3b95$export$826742c1df3eca39)(this.i18nInstance, dosagesAsText, "then");
+        }
+        // We have both "sequential" and "concurrent" instructions - time to see what is the configuration
+        let sortedDosages = this.groupBySequence(dosages);
+        // Now that data structures are filled, it is a piece of cake to generate the result
+        let sequentialInstructions = sortedDosages.map((concurrentInstructions)=>{
+            let concurrentInstructionsAsString = concurrentInstructions.map((dosage)=>this.fromDosageToText(dosage));
+            return (0, $93b58b7d2ead3b95$export$826742c1df3eca39)(this.i18nInstance, concurrentInstructionsAsString, "and");
         });
         return (0, $93b58b7d2ead3b95$export$826742c1df3eca39)(this.i18nInstance, sequentialInstructions, "then");
     }