ezmedicationinput 0.1.11 → 0.1.12

package/README.md

@@ -228,7 +228,7 @@ You can specify the number of times (total count) the medication is supposed to
 
 ### Next due dose generation
 
-`nextDueDoses` produces upcoming administration timestamps from an existing FHIR `Dosage`. Supply the evaluation window (`from`), optionally the order start (`orderedAt`), and clinic clock details such as a time zone and event timing anchors.
+`nextDueDoses` produces upcoming administration timestamps from an existing FHIR `Dosage`. Supply the evaluation window (`from`), optionally the order start (`orderedAt`), and clinic clock details such as a time zone and event timing anchors. When a `Timing.repeat.count` cap exists and prior occurrences have already been administered, pass `priorCount` to indicate how many doses were consumed before the `from` timestamp so remaining administrations are calculated correctly without re-traversing the timeline.
 
 ```ts
 import { EventTiming, nextDueDoses, parseSig } from "ezmedicationinput";

package/dist/schedule.js

@@ -475,6 +475,14 @@ function nextDueDoses(dosage, options) {
     }
     const from = coerceDate(options.from, "from");
     const orderedAt = options.orderedAt === undefined ? null : coerceDate(options.orderedAt, "orderedAt");
+    const priorCountInput = options.priorCount;
+    if (priorCountInput !== undefined) {
+        if (!Number.isFinite(priorCountInput) || priorCountInput < 0) {
+            throw new Error("Invalid priorCount supplied to nextDueDoses");
+        }
+    }
+    let priorCount = priorCountInput !== undefined ? Math.floor(priorCountInput) : 0;
+    const needsDerivedPriorCount = priorCountInput === undefined && !!orderedAt;
     const baseTime = orderedAt !== null && orderedAt !== void 0 ? orderedAt : from;
     const providedConfig = options.config;
     const timeZone = (_b = options.timeZone) !== null && _b !== void 0 ? _b : providedConfig === null || providedConfig === void 0 ? void 0 : providedConfig.timeZone;
@@ -492,6 +500,13 @@ function nextDueDoses(dosage, options) {
     };
     const timing = dosage.timing;
     const repeat = timing === null || timing === void 0 ? void 0 : timing.repeat;
+    if (needsDerivedPriorCount &&
+        orderedAt &&
+        timing &&
+        repeat &&
+        repeat.count !== undefined) {
+        priorCount = derivePriorCountFromHistory(timing, repeat, config, orderedAt, from, timeZone);
+    }
     if (!timing || !repeat) {
         return [];
     }
@@ -500,7 +515,11 @@ function nextDueDoses(dosage, options) {
     if (normalizedCount === 0) {
         return [];
     }
-    const effectiveLimit = normalizedCount !== undefined ? Math.min(limit, normalizedCount) : limit;
+    const remainingCount = normalizedCount === undefined ? undefined : Math.max(0, normalizedCount - priorCount);
+    if (remainingCount === 0) {
+        return [];
+    }
+    const effectiveLimit = remainingCount !== undefined ? Math.min(limit, remainingCount) : limit;
     const results = [];
     const seen = new Set();
     const dayFilter = new Set(((_g = repeat.dayOfWeek) !== null && _g !== void 0 ? _g : []).map((day) => day.toLowerCase()));
@@ -628,6 +647,145 @@ function nextDueDoses(dosage, options) {
     }
     return [];
 }
+function derivePriorCountFromHistory(timing, repeat, config, orderedAt, from, timeZone) {
+    var _a, _b, _c;
+    if (from <= orderedAt) {
+        return 0;
+    }
+    const normalizedCount = repeat.count === undefined
+        ? undefined
+        : Math.max(0, Math.floor(repeat.count));
+    if (normalizedCount === 0) {
+        return 0;
+    }
+    const dayFilter = new Set(((_a = repeat.dayOfWeek) !== null && _a !== void 0 ? _a : []).map((day) => day.toLowerCase()));
+    const enforceDayFilter = dayFilter.size > 0;
+    const seen = new Set();
+    let count = 0;
+    const recordCandidate = (candidate) => {
+        if (!candidate) {
+            return false;
+        }
+        if (candidate < orderedAt || candidate >= from) {
+            return false;
+        }
+        const iso = formatZonedIso(candidate, timeZone);
+        if (seen.has(iso)) {
+            return false;
+        }
+        seen.add(iso);
+        count += 1;
+        return true;
+    };
+    const whenCodes = (_b = repeat.when) !== null && _b !== void 0 ? _b : [];
+    const timeOfDayEntries = (_c = repeat.timeOfDay) !== null && _c !== void 0 ? _c : [];
+    if (whenCodes.length > 0 || timeOfDayEntries.length > 0) {
+        const expanded = expandWhenCodes(whenCodes, config, repeat);
+        if (timeOfDayEntries.length > 0) {
+            for (const clock of timeOfDayEntries) {
+                expanded.push({ time: normalizeClock(clock), dayShift: 0 });
+            }
+            expanded.sort((a, b) => {
+                if (a.dayShift !== b.dayShift) {
+                    return a.dayShift - b.dayShift;
+                }
+                return a.time.localeCompare(b.time);
+            });
+        }
+        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;
+                    }
+                }
+            }
+            currentDay = addLocalDays(currentDay, 1, timeZone);
+            iterations += 1;
+        }
+        return count;
+    }
+    const treatAsInterval = !!repeat.period &&
+        !!repeat.periodUnit &&
+        (!repeat.frequency ||
+            repeat.periodUnit !== "d" ||
+            (repeat.frequency === 1 && repeat.period > 1));
+    if (treatAsInterval) {
+        const increment = createIntervalStepper(repeat, timeZone);
+        if (!increment) {
+            return count;
+        }
+        let current = orderedAt;
+        let guard = 0;
+        const maxIterations = normalizedCount !== undefined ? normalizedCount * 1000 : 1000;
+        while (current < from && guard < maxIterations) {
+            const weekday = getLocalWeekday(current, timeZone);
+            if (!enforceDayFilter || dayFilter.has(weekday)) {
+                if (recordCandidate(current) && normalizedCount !== undefined && seen.size >= normalizedCount) {
+                    return count;
+                }
+            }
+            const next = increment(current);
+            if (!next || next.getTime() === current.getTime()) {
+                break;
+            }
+            current = next;
+            guard += 1;
+        }
+        return count;
+    }
+    if (repeat.frequency && repeat.period && repeat.periodUnit) {
+        const clocks = resolveFrequencyClocks(timing, config);
+        if (clocks.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 clock of clocks) {
+                    const zoned = makeZonedDateFromDay(currentDay, timeZone, clock);
+                    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;
+        }
+    }
+    return count;
+}
 /**
  * Generates an interval-based series by stepping forward from the base time
  * until the requested number of timestamps have been produced.

package/dist/types.d.ts

@@ -458,6 +458,7 @@ export interface NextDueDoseOptions {
     from: Date | string;
     orderedAt?: Date | string;
     limit?: number;
+    priorCount?: number;
     timeZone?: string;
     eventClock?: EventClockMap;
     mealOffsets?: MealOffsetMap;

package/package.json

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