ezmedicationinput 0.1.35 → 0.1.37

package/dist/i18n.js

@@ -551,8 +551,25 @@ function combineFrequencyAndEventsThai(frequency, events) {
     }
     return { frequency, event: joinWithAndThai(events) };
 }
+function isOralRouteThai(internal) {
+    var _a;
+    if (internal.routeCode === types_1.RouteCode["Oral route"]) {
+        return true;
+    }
+    const text = (_a = internal.routeText) === null || _a === void 0 ? void 0 : _a.trim().toLowerCase();
+    if (!text) {
+        return false;
+    }
+    return (text === "po" ||
+        text === "oral" ||
+        text.includes("mouth") ||
+        text.includes("per os"));
+}
 function buildRoutePhraseThai(internal, grammar, hasSite) {
     var _a;
+    if (grammar.verb === "รับประทาน" && isOralRouteThai(internal)) {
+        return undefined;
+    }
     if (typeof grammar.routePhrase === "function") {
         return grammar.routePhrase({ hasSite, internal });
     }

package/dist/schedule.js

@@ -419,6 +419,69 @@ function expandWhenCodes(whenCodes, config, repeat) {
         return a.time.localeCompare(b.time);
     });
 }
+const DEFAULT_WHEN_FALLBACK_CLOCKS = {
+    [types_1.EventTiming.Wake]: ["06:00:00"],
+    [types_1.EventTiming["Early Morning"]]: ["06:00:00"],
+    [types_1.EventTiming.Morning]: ["08:00:00"],
+    [types_1.EventTiming["Late Morning"]]: ["10:00:00"],
+    [types_1.EventTiming.Breakfast]: ["08:00:00"],
+    [types_1.EventTiming["Before Breakfast"]]: ["07:30:00"],
+    [types_1.EventTiming["After Breakfast"]]: ["08:30:00"],
+    [types_1.EventTiming.Noon]: ["12:00:00"],
+    [types_1.EventTiming.Lunch]: ["12:30:00"],
+    [types_1.EventTiming["Before Lunch"]]: ["12:00:00"],
+    [types_1.EventTiming["After Lunch"]]: ["13:00:00"],
+    [types_1.EventTiming["Early Afternoon"]]: ["14:00:00"],
+    [types_1.EventTiming.Afternoon]: ["15:00:00"],
+    [types_1.EventTiming["Late Afternoon"]]: ["16:00:00"],
+    [types_1.EventTiming["Early Evening"]]: ["18:00:00"],
+    [types_1.EventTiming.Evening]: ["19:00:00"],
+    [types_1.EventTiming["Late Evening"]]: ["20:00:00"],
+    [types_1.EventTiming.Dinner]: ["18:30:00"],
+    [types_1.EventTiming["Before Dinner"]]: ["18:00:00"],
+    [types_1.EventTiming["After Dinner"]]: ["19:00:00"],
+    [types_1.EventTiming.Night]: ["21:00:00"],
+    [types_1.EventTiming["Before Sleep"]]: ["22:00:00"],
+    [types_1.EventTiming["After Sleep"]]: ["06:30:00"],
+    [types_1.EventTiming.Meal]: ["08:00:00", "12:30:00", "18:30:00"],
+    [types_1.EventTiming["Before Meal"]]: ["07:30:00", "12:00:00", "18:00:00"],
+    [types_1.EventTiming["After Meal"]]: ["08:30:00", "13:00:00", "19:00:00"]
+};
+function inferWhenFallbackEntries(whenCodes, repeat) {
+    const entries = [];
+    const seen = new Set();
+    const addClock = (clock) => {
+        var _a;
+        const normalized = normalizeClock(clock);
+        const adjusted = repeat.offset
+            ? applyOffset(normalized, (_a = repeat.offset) !== null && _a !== void 0 ? _a : 0)
+            : { time: normalized, dayShift: 0 };
+        const key = `${adjusted.dayShift}|${adjusted.time}`;
+        if (seen.has(key)) {
+            return;
+        }
+        seen.add(key);
+        entries.push(adjusted);
+    };
+    for (const code of whenCodes) {
+        if (code === types_1.EventTiming.Immediate) {
+            continue;
+        }
+        const fallbackClocks = DEFAULT_WHEN_FALLBACK_CLOCKS[code];
+        if (!fallbackClocks) {
+            continue;
+        }
+        for (const clock of fallbackClocks) {
+            addClock(clock);
+        }
+    }
+    return entries.sort((a, b) => {
+        if (a.dayShift !== b.dayShift) {
+            return a.dayShift - b.dayShift;
+        }
+        return a.time.localeCompare(b.time);
+    });
+}
 function mergeFrequencyDefaults(base, override) {
     var _a, _b, _c, _d;
     if (!base && !override) {
@@ -433,6 +496,25 @@ function mergeFrequencyDefaults(base, override) {
     }
     return merged;
 }
+function inferDailyFrequencyClocks(frequency) {
+    if (!Number.isFinite(frequency) || frequency <= 0) {
+        return [];
+    }
+    if (frequency === 1) {
+        return ["09:00:00"];
+    }
+    const startMinutes = 8 * 60;
+    const endMinutes = 20 * 60;
+    const spanMinutes = endMinutes - startMinutes;
+    const clocks = new Set();
+    for (let index = 0; index < frequency; index += 1) {
+        const minutes = startMinutes + Math.round((spanMinutes * index) / (frequency - 1));
+        const hour = Math.floor(minutes / SECONDS_PER_MINUTE);
+        const minute = minutes % SECONDS_PER_MINUTE;
+        clocks.add(`${pad(hour)}:${pad(minute)}:00`);
+    }
+    return Array.from(clocks).sort();
+}
 /** Resolves fallback clock arrays for frequency-only schedules. */
 function resolveFrequencyClocks(timing, config) {
     var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
@@ -462,6 +544,11 @@ function resolveFrequencyClocks(timing, config) {
                 collected.add(normalizeClock(clock));
             }
         }
+        if (collected.size === 0 && repeat.period === 1 && repeat.periodUnit === "d") {
+            for (const clock of inferDailyFrequencyClocks(repeat.frequency)) {
+                collected.add(clock);
+            }
+        }
     }
     return Array.from(collected).sort();
 }
@@ -547,6 +634,11 @@ function nextDueDoses(dosage, options) {
                 return a.time.localeCompare(b.time);
             });
         }
+        if (expanded.length === 0 &&
+            timeOfDayEntries.length === 0 &&
+            (!repeat.frequency || !repeat.period || !repeat.periodUnit)) {
+            expanded.push(...inferWhenFallbackEntries(whenCodes, repeat));
+        }
         const includesImmediate = (0, array_1.arrayIncludes)(whenCodes, types_1.EventTiming.Immediate);
         if (includesImmediate) {
             const immediateSource = orderedAt !== null && orderedAt !== void 0 ? orderedAt : from;
@@ -561,46 +653,53 @@ function nextDueDoses(dosage, options) {
         if (results.length >= effectiveLimit) {
             return results.slice(0, effectiveLimit);
         }
-        if (expanded.length === 0) {
-            return results.slice(0, effectiveLimit);
-        }
-        let currentDay = startOfLocalDay(from, timeZone);
-        let iterations = 0;
-        const maxIterations = effectiveLimit * 31;
-        while (results.length < effectiveLimit && iterations < maxIterations) {
-            const weekday = getLocalWeekday(currentDay, timeZone);
-            if (!enforceDayFilter || dayFilter.has(weekday)) {
-                for (const entry of expanded) {
-                    const targetDay = entry.dayShift === 0
-                        ? currentDay
-                        : addLocalDays(currentDay, entry.dayShift, timeZone);
-                    const zoned = makeZonedDateFromDay(targetDay, timeZone, entry.time);
-                    if (!zoned) {
-                        continue;
-                    }
-                    if (zoned < from) {
-                        continue;
-                    }
-                    if (orderedAt && zoned < orderedAt) {
-                        continue;
-                    }
-                    const iso = formatZonedIso(zoned, timeZone);
-                    if (!seen.has(iso)) {
-                        seen.add(iso);
-                        results.push(iso);
-                        if (results.length === effectiveLimit) {
-                            break;
+        const canFallbackToFrequency = expanded.length === 0 &&
+            timeOfDayEntries.length === 0 &&
+            !!repeat.frequency &&
+            !!repeat.period &&
+            !!repeat.periodUnit;
+        if (!canFallbackToFrequency) {
+            if (expanded.length === 0) {
+                return results.slice(0, effectiveLimit);
+            }
+            let currentDay = startOfLocalDay(from, timeZone);
+            let iterations = 0;
+            const maxIterations = effectiveLimit * 31;
+            while (results.length < effectiveLimit && iterations < maxIterations) {
+                const weekday = getLocalWeekday(currentDay, timeZone);
+                if (!enforceDayFilter || dayFilter.has(weekday)) {
+                    for (const entry of expanded) {
+                        const targetDay = entry.dayShift === 0
+                            ? currentDay
+                            : addLocalDays(currentDay, entry.dayShift, timeZone);
+                        const zoned = makeZonedDateFromDay(targetDay, timeZone, entry.time);
+                        if (!zoned) {
+                            continue;
+                        }
+                        if (zoned < from) {
+                            continue;
+                        }
+                        if (orderedAt && zoned < orderedAt) {
+                            continue;
+                        }
+                        const iso = formatZonedIso(zoned, timeZone);
+                        if (!seen.has(iso)) {
+                            seen.add(iso);
+                            results.push(iso);
+                            if (results.length === effectiveLimit) {
+                                break;
+                            }
                         }
                     }
                 }
+                if (results.length >= effectiveLimit) {
+                    break;
+                }
+                currentDay = addLocalDays(currentDay, 1, timeZone);
+                iterations += 1;
             }
-            if (results.length >= effectiveLimit) {
-                break;
-            }
-            currentDay = addLocalDays(currentDay, 1, timeZone);
-            iterations += 1;
+            return results.slice(0, effectiveLimit);
         }
-        return results.slice(0, effectiveLimit);
     }
     const treatAsInterval = !!repeat.period &&
         !!repeat.periodUnit &&
@@ -700,40 +799,52 @@ function derivePriorCountFromHistory(timing, repeat, config, orderedAt, from, ti
                 return a.time.localeCompare(b.time);
             });
         }
+        if (expanded.length === 0 &&
+            timeOfDayEntries.length === 0 &&
+            (!repeat.frequency || !repeat.period || !repeat.periodUnit)) {
+            expanded.push(...inferWhenFallbackEntries(whenCodes, repeat));
+        }
         if ((0, array_1.arrayIncludes)(whenCodes, types_1.EventTiming.Immediate)) {
             if (recordCandidate(orderedAt) && normalizedCount !== undefined && seen.size >= normalizedCount) {
                 return count;
             }
         }
-        if (expanded.length === 0) {
-            return count;
-        }
-        let currentDay = startOfLocalDay(orderedAt, timeZone);
-        let iterations = 0;
-        const maxIterations = normalizedCount !== undefined ? normalizedCount * 31 : 31 * 365;
-        while (currentDay < from && iterations < maxIterations) {
-            const weekday = getLocalWeekday(currentDay, timeZone);
-            if (!enforceDayFilter || dayFilter.has(weekday)) {
-                for (const entry of expanded) {
-                    const targetDay = entry.dayShift === 0
-                        ? currentDay
-                        : addLocalDays(currentDay, entry.dayShift, timeZone);
-                    const zoned = makeZonedDateFromDay(targetDay, timeZone, entry.time);
-                    if (!zoned) {
-                        continue;
-                    }
-                    if (zoned < orderedAt || zoned >= from) {
-                        continue;
-                    }
-                    if (recordCandidate(zoned) && normalizedCount !== undefined && seen.size >= normalizedCount) {
-                        return count;
+        const canFallbackToFrequency = expanded.length === 0 &&
+            timeOfDayEntries.length === 0 &&
+            !!repeat.frequency &&
+            !!repeat.period &&
+            !!repeat.periodUnit;
+        if (!canFallbackToFrequency) {
+            if (expanded.length === 0) {
+                return count;
+            }
+            let currentDay = startOfLocalDay(orderedAt, timeZone);
+            let iterations = 0;
+            const maxIterations = normalizedCount !== undefined ? normalizedCount * 31 : 31 * 365;
+            while (currentDay < from && iterations < maxIterations) {
+                const weekday = getLocalWeekday(currentDay, timeZone);
+                if (!enforceDayFilter || dayFilter.has(weekday)) {
+                    for (const entry of expanded) {
+                        const targetDay = entry.dayShift === 0
+                            ? currentDay
+                            : addLocalDays(currentDay, entry.dayShift, timeZone);
+                        const zoned = makeZonedDateFromDay(targetDay, timeZone, entry.time);
+                        if (!zoned) {
+                            continue;
+                        }
+                        if (zoned < orderedAt || zoned >= from) {
+                            continue;
+                        }
+                        if (recordCandidate(zoned) && normalizedCount !== undefined && seen.size >= normalizedCount) {
+                            return count;
+                        }
                     }
                 }
+                currentDay = addLocalDays(currentDay, 1, timeZone);
+                iterations += 1;
             }
-            currentDay = addLocalDays(currentDay, 1, timeZone);
-            iterations += 1;
+            return count;
         }
-        return count;
     }
     const treatAsInterval = !!repeat.period &&
         !!repeat.periodUnit &&
@@ -943,33 +1054,45 @@ function countScheduleEvents(dosage, from, to, config, baseTime, orderedAt, limi
                 return a.time.localeCompare(b.time);
             });
         }
+        if (expanded.length === 0 &&
+            timeOfDayEntries.length === 0 &&
+            (!repeat.frequency || !repeat.period || !repeat.periodUnit)) {
+            expanded.push(...inferWhenFallbackEntries(whenCodes, repeat));
+        }
         if ((0, array_1.arrayIncludes)(whenCodes, types_1.EventTiming.Immediate)) {
             const immediateSource = orderedAt !== null && orderedAt !== void 0 ? orderedAt : from;
             if (!orderedAt || orderedAt >= from) {
                 recordCandidate(immediateSource);
             }
         }
-        if (expanded.length === 0)
-            return count;
-        let currentDay = startOfLocalDay(from, timeZone);
-        let iterations = 0;
-        const maxIterations = limit !== undefined ? limit * 31 : 365 * 31;
-        while (count < (limit !== null && limit !== void 0 ? limit : Infinity) && currentDay < to && iterations < maxIterations) {
-            const weekday = getLocalWeekday(currentDay, timeZone);
-            if (!enforceDayFilter || dayFilter.has(weekday)) {
-                for (const entry of expanded) {
-                    const targetDay = entry.dayShift === 0
-                        ? currentDay
-                        : addLocalDays(currentDay, entry.dayShift, timeZone);
-                    const zoned = makeZonedDateFromDay(targetDay, timeZone, entry.time);
-                    if (zoned)
-                        recordCandidate(zoned);
+        const canFallbackToFrequency = expanded.length === 0 &&
+            timeOfDayEntries.length === 0 &&
+            !!repeat.frequency &&
+            !!repeat.period &&
+            !!repeat.periodUnit;
+        if (!canFallbackToFrequency) {
+            if (expanded.length === 0)
+                return count;
+            let currentDay = startOfLocalDay(from, timeZone);
+            let iterations = 0;
+            const maxIterations = limit !== undefined ? limit * 31 : 365 * 31;
+            while (count < (limit !== null && limit !== void 0 ? limit : Infinity) && currentDay < to && iterations < maxIterations) {
+                const weekday = getLocalWeekday(currentDay, timeZone);
+                if (!enforceDayFilter || dayFilter.has(weekday)) {
+                    for (const entry of expanded) {
+                        const targetDay = entry.dayShift === 0
+                            ? currentDay
+                            : addLocalDays(currentDay, entry.dayShift, timeZone);
+                        const zoned = makeZonedDateFromDay(targetDay, timeZone, entry.time);
+                        if (zoned)
+                            recordCandidate(zoned);
+                    }
                 }
+                currentDay = addLocalDays(currentDay, 1, timeZone);
+                iterations += 1;
             }
-            currentDay = addLocalDays(currentDay, 1, timeZone);
-            iterations += 1;
+            return count;
         }
-        return count;
     }
     const treatAsInterval = !!repeat.period &&
         !!repeat.periodUnit &&
@@ -1047,7 +1170,7 @@ function countScheduleEvents(dosage, from, to, config, baseTime, orderedAt, limi
     }
     return count;
 }
-function calculateTotalUnits(options) {
+function calculateTotalUnitsSingle(options) {
     var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
     const { dosage, durationValue, durationUnit, roundToMultiple, context } = options;
     const from = coerceDate(options.from, "from");
@@ -1102,3 +1225,24 @@ function calculateTotalUnits(options) {
     }
     return result;
 }
+function calculateTotalUnits(options) {
+    if (Array.isArray(options.dosage)) {
+        const hasAnyDosage = options.dosage.length > 0;
+        if (!hasAnyDosage) {
+            return { totalUnits: 0 };
+        }
+        let totalUnits = 0;
+        let totalContainers = 0;
+        let sawContainers = false;
+        for (const dosage of options.dosage) {
+            const result = calculateTotalUnitsSingle(Object.assign(Object.assign({}, options), { dosage }));
+            totalUnits += result.totalUnits;
+            if (result.totalContainers !== undefined) {
+                totalContainers += result.totalContainers;
+                sawContainers = true;
+            }
+        }
+        return sawContainers ? { totalUnits, totalContainers } : { totalUnits };
+    }
+    return calculateTotalUnitsSingle(options);
+}

package/dist/types.d.ts

@@ -673,7 +673,7 @@ export interface TotalUnitsResult {
     totalContainers?: number;
 }
 export interface TotalUnitsOptions extends NextDueDoseOptions {
-    dosage: FhirDosage;
+    dosage: FhirDosage | FhirDosage[];
     durationValue: number;
     durationUnit: FhirPeriodUnit;
     roundToMultiple?: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ezmedicationinput",
-  "version": "0.1.35",
+  "version": "0.1.37",
   "description": "Parse concise medication sigs into FHIR R5 Dosage JSON",
   "type": "module",
   "main": "dist/index.js",