ezmedicationinput 0.1.1 → 0.1.3

package/dist/suggest.js

@@ -1,48 +1,124 @@
-import { inferUnitFromContext } from "./context";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.suggestSig = suggestSig;
+const context_1 = require("./context");
+const maps_1 = require("./maps");
+const types_1 = require("./types");
 const DEFAULT_LIMIT = 10;
+const HOUSEHOLD_VOLUME_UNIT_SET = new Set(maps_1.HOUSEHOLD_VOLUME_UNITS.map((unit) => unit.trim().toLowerCase()));
+const ROUTE_TOKEN_BY_CODE = {
+    [types_1.RouteCode["Oral route"]]: "po",
+    [types_1.RouteCode["Respiratory tract route (qualifier value)"]]: "inh",
+    [types_1.RouteCode["Nasal route"]]: "in",
+    [types_1.RouteCode["Ophthalmic route"]]: "oph",
+    [types_1.RouteCode["Per rectum"]]: "pr",
+    [types_1.RouteCode["Transdermal route"]]: "transdermal",
+    [types_1.RouteCode["Topical route"]]: "topical",
+};
 const DEFAULT_UNIT_ROUTE_ORDER = [
-    { unit: "tab", route: "po" },
-    { unit: "cap", route: "po" },
-    { unit: "mL", route: "po" },
-    { unit: "mg", route: "po" },
-    { unit: "puff", route: "inh" },
-    { unit: "spray", route: "in" },
-    { unit: "drop", route: "oph" },
-    { unit: "suppository", route: "pr" },
-    { unit: "patch", route: "transdermal" },
-    { unit: "g", route: "topical" }
+    { unit: "tab", routeCode: types_1.RouteCode["Oral route"] },
+    { unit: "cap", routeCode: types_1.RouteCode["Oral route"] },
+    { unit: "tsp", routeCode: types_1.RouteCode["Oral route"] },
+    { unit: "tbsp", routeCode: types_1.RouteCode["Oral route"] },
+    { unit: "mL", routeCode: types_1.RouteCode["Oral route"] },
+    { unit: "L", routeCode: types_1.RouteCode["Oral route"] },
+    { unit: "mcL", routeCode: types_1.RouteCode["Oral route"] },
+    { unit: "nL", routeCode: types_1.RouteCode["Oral route"] },
+    { unit: "mg", routeCode: types_1.RouteCode["Oral route"] },
+    { unit: "mcg", routeCode: types_1.RouteCode["Oral route"] },
+    { unit: "ng", routeCode: types_1.RouteCode["Oral route"] },
+    { unit: "g", routeCode: types_1.RouteCode["Topical route"] },
+    { unit: "kg", routeCode: types_1.RouteCode["Topical route"] },
+    { unit: "puff", routeCode: types_1.RouteCode["Respiratory tract route (qualifier value)"] },
+    { unit: "spray", routeCode: types_1.RouteCode["Nasal route"] },
+    { unit: "drop", routeCode: types_1.RouteCode["Ophthalmic route"] },
+    { unit: "suppository", routeCode: types_1.RouteCode["Per rectum"] },
+    { unit: "patch", routeCode: types_1.RouteCode["Transdermal route"] },
 ];
-const DEFAULT_ROUTE_BY_UNIT = {
-    tab: "po",
-    tabs: "po",
-    tablet: "po",
-    cap: "po",
-    capsule: "po",
-    ml: "po",
-    mg: "po",
-    puff: "inh",
-    puffs: "inh",
-    spray: "in",
-    sprays: "in",
-    drop: "oph",
-    drops: "oph",
-    suppository: "pr",
-    suppositories: "pr",
-    patch: "transdermal",
-    patches: "transdermal",
-    g: "topical"
-};
-const FREQUENCY_CODES = ["qd", "bid", "tid", "qid"];
-const INTERVAL_CODES = ["q4h", "q6h", "q8h"];
-const WHEN_TOKENS = ["ac", "pc", "hs", "am", "pm"];
-const CORE_WHEN_TOKENS = ["pc", "ac", "hs"];
-const FREQUENCY_NUMBERS = [1, 2, 3, 4];
-const FREQ_TOKEN_BY_NUMBER = {
-    1: "qd",
-    2: "bid",
-    3: "tid",
-    4: "qid",
-};
+const ROUTE_TOKEN_BY_UNIT = (() => {
+    var _a, _b, _c;
+    const map = new Map();
+    const assign = (unit, token) => {
+        if (!unit || !token) {
+            return;
+        }
+        const normalizedUnit = normalizeKey(unit);
+        if (!normalizedUnit || map.has(normalizedUnit)) {
+            return;
+        }
+        map.set(normalizedUnit, normalizeSpacing(token));
+    };
+    for (const routeCodeKey in maps_1.DEFAULT_UNIT_BY_ROUTE) {
+        if (!Object.prototype.hasOwnProperty.call(maps_1.DEFAULT_UNIT_BY_ROUTE, routeCodeKey)) {
+            continue;
+        }
+        const routeCode = routeCodeKey;
+        const unit = maps_1.DEFAULT_UNIT_BY_ROUTE[routeCode];
+        if (!unit) {
+            continue;
+        }
+        const token = (_a = ROUTE_TOKEN_BY_CODE[routeCode]) !== null && _a !== void 0 ? _a : maps_1.ROUTE_TEXT[routeCode];
+        assign(unit, token);
+    }
+    for (const preference of DEFAULT_UNIT_ROUTE_ORDER) {
+        const token = (_c = (_b = preference.routeToken) !== null && _b !== void 0 ? _b : ROUTE_TOKEN_BY_CODE[preference.routeCode]) !== null && _c !== void 0 ? _c : maps_1.ROUTE_TEXT[preference.routeCode];
+        assign(preference.unit, token);
+    }
+    return map;
+})();
+const BASE_INTERVAL_CODES = Object.keys(maps_1.TIMING_ABBREVIATIONS)
+    .filter((token) => /^q\d+h$/.test(token))
+    .sort((a, b) => Number.parseInt(a.slice(1, -1), 10) - Number.parseInt(b.slice(1, -1), 10));
+const DEFAULT_INTERVAL_RANGES = ["q2-4h", "q4-6h", "q6-8h", "q8-12h"];
+const BASE_WHEN_TOKEN_CANDIDATES = [
+    "ac",
+    "pc",
+    "hs",
+    "am",
+    "pm",
+    "morn",
+    "morning",
+    "noon",
+    "afternoon",
+    "evening",
+    "night",
+    "bedtime",
+    "wake",
+    "waking",
+    "breakfast",
+    "lunch",
+    "dinner",
+    "stat",
+];
+const WHEN_TOKENS = BASE_WHEN_TOKEN_CANDIDATES.filter((token) => maps_1.EVENT_TIMING_TOKENS[token] !== undefined);
+const WHEN_COMBINATIONS = [
+    "am",
+    "morning",
+    "morn",
+    "noon",
+    "afternoon",
+    "pm",
+    "evening",
+    "night",
+    "hs",
+    "bedtime",
+].filter((token) => maps_1.EVENT_TIMING_TOKENS[token] !== undefined);
+const CORE_WHEN_TOKENS = ["pc", "ac", "hs"].filter((token) => maps_1.EVENT_TIMING_TOKENS[token] !== undefined);
+const FREQUENCY_CODES = ["qd", "od", "bid", "tid", "qid"].filter((token) => maps_1.TIMING_ABBREVIATIONS[token] !== undefined);
+const FREQ_TOKEN_BY_NUMBER = {};
+for (const [frequency, token] of [
+    [1, "qd"],
+    [2, "bid"],
+    [3, "tid"],
+    [4, "qid"],
+]) {
+    if (maps_1.TIMING_ABBREVIATIONS[token]) {
+        FREQ_TOKEN_BY_NUMBER[frequency] = token;
+    }
+}
+const FREQUENCY_NUMBERS = Object.keys(FREQ_TOKEN_BY_NUMBER)
+    .map((value) => Number.parseInt(value, 10))
+    .sort((a, b) => a - b);
 const DEFAULT_PRN_REASONS = [
     "pain",
     "nausea",
@@ -56,6 +132,72 @@ const DEFAULT_PRN_REASONS = [
     "dyspnea",
 ];
 const DEFAULT_DOSE_COUNTS = ["1", "2"];
+const OPTIONAL_MATCH_TOKENS = new Set([
+    "to",
+    "into",
+    "in",
+    "on",
+    "onto",
+    "per",
+    "for",
+    "the",
+    "od",
+    "os",
+    "ou",
+]);
+const ROUTE_TOKEN_FRAGMENTS = new Set();
+for (const phrase of Object.keys(maps_1.DEFAULT_ROUTE_SYNONYMS)) {
+    for (const fragment of phrase.split(/\s+/)) {
+        const normalized = fragment.trim();
+        if (normalized) {
+            ROUTE_TOKEN_FRAGMENTS.add(normalized);
+        }
+    }
+}
+const SKIPPABLE_CANDIDATE_TOKENS = new Set([
+    ...Array.from(OPTIONAL_MATCH_TOKENS),
+    ...Array.from(ROUTE_TOKEN_FRAGMENTS),
+]);
+const UNIT_LOOKUP = (() => {
+    const canonicalByKey = new Map();
+    const variantsByCanonical = new Map();
+    const registerVariant = (canonical, variant) => {
+        const normalizedCanonical = normalizeKey(canonical);
+        if (!normalizedCanonical) {
+            return;
+        }
+        let variants = variantsByCanonical.get(normalizedCanonical);
+        if (!variants) {
+            variants = new Set();
+            variantsByCanonical.set(normalizedCanonical, variants);
+        }
+        variants.add(normalizeSpacing(canonical));
+        variants.add(normalizeSpacing(variant));
+    };
+    for (const token in maps_1.DEFAULT_UNIT_SYNONYMS) {
+        if (!Object.prototype.hasOwnProperty.call(maps_1.DEFAULT_UNIT_SYNONYMS, token)) {
+            continue;
+        }
+        const canonicalValue = maps_1.DEFAULT_UNIT_SYNONYMS[token];
+        const canonical = normalizeSpacing(canonicalValue);
+        registerVariant(canonical, canonical);
+        registerVariant(canonical, token);
+        canonicalByKey.set(normalizeKey(token), canonical);
+        canonicalByKey.set(normalizeKey(canonical), canonical);
+    }
+    return { canonicalByKey, variantsByCanonical };
+})();
+function resolveCanonicalUnit(unit) {
+    var _a;
+    if (!unit) {
+        return undefined;
+    }
+    const normalized = normalizeKey(unit);
+    if (!normalized) {
+        return undefined;
+    }
+    return (_a = UNIT_LOOKUP.canonicalByKey.get(normalized)) !== null && _a !== void 0 ? _a : normalizeSpacing(unit);
+}
 function normalizeKey(value) {
     return value.trim().toLowerCase();
 }
@@ -64,32 +206,153 @@ function normalizeSpacing(value) {
         .trim()
         .replace(/\s+/g, " ");
 }
-function buildUnitRoutePairs(contextUnit) {
+function getUnitVariants(unit) {
+    var _a;
+    const canonical = (_a = resolveCanonicalUnit(unit)) !== null && _a !== void 0 ? _a : normalizeSpacing(unit);
+    const normalizedCanonical = normalizeKey(canonical);
+    const variants = new Set();
+    const push = (candidate) => {
+        if (!candidate) {
+            return;
+        }
+        const normalizedCandidate = normalizeSpacing(candidate);
+        if (!normalizedCandidate) {
+            return;
+        }
+        variants.add(normalizedCandidate);
+    };
+    push(canonical);
+    push(unit);
+    const canonicalVariants = UNIT_LOOKUP.variantsByCanonical.get(normalizedCanonical);
+    if (canonicalVariants) {
+        for (const candidate of canonicalVariants) {
+            push(candidate);
+        }
+    }
+    return [...variants];
+}
+function buildIntervalTokens(input) {
+    const intervals = new Set();
+    const add = (token) => {
+        if (!token) {
+            return;
+        }
+        const normalized = token.trim().toLowerCase();
+        if (!normalized) {
+            return;
+        }
+        intervals.add(normalized);
+    };
+    for (const token of BASE_INTERVAL_CODES) {
+        add(token);
+    }
+    for (const token of DEFAULT_INTERVAL_RANGES) {
+        add(token);
+    }
+    const normalizedInput = input.toLowerCase();
+    const rawTokens = normalizedInput.split(/[^a-z0-9-]+/g);
+    for (const rawToken of rawTokens) {
+        if (!rawToken) {
+            continue;
+        }
+        const match = rawToken.match(/^q(\d{1,2})(?:-(\d{1,2}))?(h?)$/);
+        if (!match) {
+            continue;
+        }
+        const first = Number.parseInt(match[1], 10);
+        const second = match[2] ? Number.parseInt(match[2], 10) : undefined;
+        if (Number.isNaN(first) || first <= 0 || first > 48) {
+            continue;
+        }
+        if (second !== undefined) {
+            if (Number.isNaN(second) || second < first || second > 48) {
+                continue;
+            }
+        }
+        const normalized = `q${first}${second ? `-${second}` : ""}h`;
+        add(normalized);
+    }
+    return [...intervals];
+}
+function buildWhenSequences() {
+    const sequences = [];
+    for (const token of WHEN_TOKENS) {
+        sequences.push([token]);
+    }
+    for (let i = 0; i < WHEN_COMBINATIONS.length; i++) {
+        const first = WHEN_COMBINATIONS[i];
+        for (let j = i + 1; j < WHEN_COMBINATIONS.length; j++) {
+            const second = WHEN_COMBINATIONS[j];
+            sequences.push([first, second]);
+        }
+    }
+    return sequences;
+}
+function tokenizeForMatching(value) {
+    return value
+        .toLowerCase()
+        .split(/\s+/)
+        .map((token) => token.replace(/^[^a-z0-9-]+|[^a-z0-9-]+$/g, ""))
+        .filter((token) => token.length > 0)
+        .filter((token) => !OPTIONAL_MATCH_TOKENS.has(token));
+}
+function canonicalizeForMatching(value) {
+    return tokenizeForMatching(value).join(" ");
+}
+function tokensMatch(prefixTokens, candidateTokens) {
+    if (prefixTokens.length === 0) {
+        return true;
+    }
+    let prefixIndex = 0;
+    for (const candidateToken of candidateTokens) {
+        if (prefixIndex >= prefixTokens.length) {
+            return true;
+        }
+        const prefixToken = prefixTokens[prefixIndex];
+        if (candidateToken.startsWith(prefixToken)) {
+            prefixIndex += 1;
+            if (prefixIndex >= prefixTokens.length) {
+                return true;
+            }
+            continue;
+        }
+        if (!SKIPPABLE_CANDIDATE_TOKENS.has(candidateToken)) {
+            return false;
+        }
+    }
+    return prefixIndex >= prefixTokens.length;
+}
+function buildUnitRoutePairs(contextUnit, options) {
+    var _a, _b;
     const pairs = [];
     const seen = new Set();
-    const addPair = (unit, route) => {
-        if (!unit) {
+    const addPair = (unit, routeOverride) => {
+        var _a;
+        const canonicalUnit = resolveCanonicalUnit(unit);
+        if (!canonicalUnit) {
             return;
         }
-        const cleanUnit = unit.trim();
-        if (!cleanUnit) {
+        const normalizedUnit = normalizeKey(canonicalUnit);
+        if ((options === null || options === void 0 ? void 0 : options.allowHouseholdVolumeUnits) === false &&
+            HOUSEHOLD_VOLUME_UNIT_SET.has(normalizedUnit)) {
             return;
         }
-        const normalizedUnit = cleanUnit.toLowerCase();
-        const resolvedRoute = route ?? DEFAULT_ROUTE_BY_UNIT[normalizedUnit] ?? "po";
-        const key = `${normalizedUnit}::${resolvedRoute.toLowerCase()}`;
+        const resolvedRoute = (_a = routeOverride !== null && routeOverride !== void 0 ? routeOverride : ROUTE_TOKEN_BY_UNIT.get(normalizedUnit)) !== null && _a !== void 0 ? _a : "po";
+        const cleanRoute = normalizeSpacing(resolvedRoute);
+        if (!cleanRoute) {
+            return;
+        }
+        const key = `${normalizedUnit}::${normalizeKey(cleanRoute)}`;
         if (seen.has(key)) {
             return;
         }
         seen.add(key);
-        pairs.push({ unit: cleanUnit, route: resolvedRoute });
+        pairs.push({ unit: canonicalUnit, route: cleanRoute });
     };
-    if (contextUnit) {
-        const normalized = normalizeKey(contextUnit);
-        addPair(contextUnit, DEFAULT_ROUTE_BY_UNIT[normalized]);
-    }
-    for (const pair of DEFAULT_UNIT_ROUTE_ORDER) {
-        addPair(pair.unit, pair.route);
+    addPair(contextUnit);
+    for (const preference of DEFAULT_UNIT_ROUTE_ORDER) {
+        const routeToken = (_b = (_a = preference.routeToken) !== null && _a !== void 0 ? _a : ROUTE_TOKEN_BY_CODE[preference.routeCode]) !== null && _b !== void 0 ? _b : maps_1.ROUTE_TEXT[preference.routeCode];
+        addPair(preference.unit, routeToken);
     }
     return pairs;
 }
@@ -140,7 +403,7 @@ function buildDoseValues(input) {
     }
     return [...values];
 }
-function generateCandidateSignatures(pairs, doseValues, prnReasons) {
+function generateCandidateDirections(pairs, doseValues, prnReasons, intervalTokens, whenSequences) {
     const suggestions = [];
     const seen = new Set();
     const push = (value) => {
@@ -156,41 +419,57 @@ function generateCandidateSignatures(pairs, doseValues, prnReasons) {
         suggestions.push(normalized);
     };
     for (const pair of pairs) {
+        const unitVariants = getUnitVariants(pair.unit);
         for (const code of FREQUENCY_CODES) {
-            for (const dose of doseValues) {
-                push(`${dose} ${pair.unit} ${pair.route} ${code}`);
+            for (const unitVariant of unitVariants) {
+                for (const dose of doseValues) {
+                    push(`${dose} ${unitVariant} ${pair.route} ${code}`);
+                }
             }
             push(`${pair.route} ${code}`);
         }
-        for (const interval of INTERVAL_CODES) {
-            for (const dose of doseValues) {
-                push(`${dose} ${pair.unit} ${pair.route} ${interval}`);
-                for (const reason of prnReasons) {
-                    push(`${dose} ${pair.unit} ${pair.route} ${interval} prn ${reason}`);
+        for (const interval of intervalTokens) {
+            for (const unitVariant of unitVariants) {
+                for (const dose of doseValues) {
+                    push(`${dose} ${unitVariant} ${pair.route} ${interval}`);
+                    for (const reason of prnReasons) {
+                        push(`${dose} ${unitVariant} ${pair.route} ${interval} prn ${reason}`);
+                    }
                 }
             }
             push(`${pair.route} ${interval}`);
         }
         for (const freq of FREQUENCY_NUMBERS) {
             const freqToken = FREQ_TOKEN_BY_NUMBER[freq];
+            if (!freqToken) {
+                continue;
+            }
             push(`1x${freq} ${pair.route} ${freqToken}`);
             for (const when of CORE_WHEN_TOKENS) {
                 push(`1x${freq} ${pair.route} ${when}`);
             }
         }
-        for (const when of WHEN_TOKENS) {
-            for (const dose of doseValues) {
-                push(`${dose} ${pair.unit} ${pair.route} ${when}`);
+        for (const whenSequence of whenSequences) {
+            const suffix = whenSequence.join(" ");
+            for (const unitVariant of unitVariants) {
+                for (const dose of doseValues) {
+                    push(`${dose} ${unitVariant} ${pair.route} ${suffix}`);
+                }
             }
-            push(`${pair.route} ${when}`);
+            push(`${pair.route} ${suffix}`);
         }
         for (const reason of prnReasons) {
-            push(`1 ${pair.unit} ${pair.route} prn ${reason}`);
+            for (const unitVariant of unitVariants) {
+                for (const dose of doseValues) {
+                    push(`${dose} ${unitVariant} ${pair.route} prn ${reason}`);
+                }
+            }
+            push(`${pair.route} prn ${reason}`);
         }
     }
     return suggestions;
 }
-function matchesPrefix(candidate, prefix, prefixCompact) {
+function matchesPrefix(candidate, prefix, prefixCompact, prefixTokens, prefixTokensNoDashes, prefixCanonical, prefixCanonicalCompact, prefixNoDashes, prefixCanonicalNoDashes) {
     if (!prefix) {
         return true;
     }
@@ -199,20 +478,53 @@ function matchesPrefix(candidate, prefix, prefixCompact) {
         return true;
     }
     const compactCandidate = normalizedCandidate.replace(/\s+/g, "");
-    return compactCandidate.startsWith(prefixCompact);
+    if (compactCandidate.startsWith(prefixCompact)) {
+        return true;
+    }
+    const candidateNoDashes = normalizedCandidate.replace(/-/g, "");
+    if (candidateNoDashes.startsWith(prefixNoDashes)) {
+        return true;
+    }
+    const canonicalCandidate = canonicalizeForMatching(candidate);
+    if (canonicalCandidate.startsWith(prefixCanonical)) {
+        return true;
+    }
+    const canonicalCompact = canonicalCandidate.replace(/\s+/g, "");
+    if (canonicalCompact.startsWith(prefixCanonicalCompact)) {
+        return true;
+    }
+    const candidateTokens = tokenizeForMatching(candidate);
+    if (tokensMatch(prefixTokens, candidateTokens)) {
+        return true;
+    }
+    const canonicalNoDashes = canonicalCandidate.replace(/-/g, "");
+    if (canonicalNoDashes.startsWith(prefixCanonicalNoDashes)) {
+        return true;
+    }
+    const candidateTokensNoDashes = candidateTokens.map((token) => token.replace(/-/g, ""));
+    return tokensMatch(prefixTokensNoDashes, candidateTokensNoDashes);
 }
-export function suggestSig(input, options) {
-    const limit = options?.limit ?? DEFAULT_LIMIT;
+function suggestSig(input, options) {
+    var _a, _b;
+    const limit = (_a = options === null || options === void 0 ? void 0 : options.limit) !== null && _a !== void 0 ? _a : DEFAULT_LIMIT;
     const prefix = normalizeSpacing(input.toLowerCase());
     const prefixCompact = prefix.replace(/\s+/g, "");
-    const contextUnit = inferUnitFromContext(options?.context ?? undefined);
-    const pairs = buildUnitRoutePairs(contextUnit);
+    const prefixNoDashes = prefix.replace(/-/g, "");
+    const prefixCanonical = canonicalizeForMatching(prefix);
+    const prefixCanonicalCompact = prefixCanonical.replace(/\s+/g, "");
+    const prefixCanonicalNoDashes = prefixCanonical.replace(/-/g, "");
+    const prefixTokens = tokenizeForMatching(prefixCanonical);
+    const prefixTokensNoDashes = prefixTokens.map((token) => token.replace(/-/g, ""));
+    const contextUnit = (0, context_1.inferUnitFromContext)((_b = options === null || options === void 0 ? void 0 : options.context) !== null && _b !== void 0 ? _b : undefined);
+    const pairs = buildUnitRoutePairs(contextUnit, options);
     const doseValues = buildDoseValues(input);
-    const prnReasons = buildPrnReasons(options?.prnReasons);
-    const candidates = generateCandidateSignatures(pairs, doseValues, prnReasons);
+    const prnReasons = buildPrnReasons(options === null || options === void 0 ? void 0 : options.prnReasons);
+    const intervalTokens = buildIntervalTokens(input);
+    const whenSequences = buildWhenSequences();
+    const candidates = generateCandidateDirections(pairs, doseValues, prnReasons, intervalTokens, whenSequences);
     const results = [];
     for (const candidate of candidates) {
-        if (matchesPrefix(candidate, prefix, prefixCompact)) {
+        if (matchesPrefix(candidate, prefix, prefixCompact, prefixTokens, prefixTokensNoDashes, prefixCanonical, prefixCanonicalCompact, prefixNoDashes, prefixCanonicalNoDashes)) {
             results.push(candidate);
         }
         if (results.length >= limit) {

package/dist/types.d.ts

@@ -1,3 +1,4 @@
+import type { SigTranslationConfig } from "./i18n";
 export interface FhirCoding {
     system?: string;
     code?: string;
@@ -283,7 +284,11 @@ export interface MedicationContext {
     containerUnit?: string;
     defaultUnit?: string;
 }
-export interface ParseOptions {
+export interface FormatOptions {
+    locale?: "en" | "th" | string;
+    i18n?: SigTranslationConfig;
+}
+export interface ParseOptions extends FormatOptions {
     /**
      * Optional medication context that assists with default unit inference.
      * May be omitted or explicitly set to null when no contextual clues exist.
@@ -298,8 +303,12 @@ export interface ParseOptions {
         intervalWeeks?: number;
     }>;
     whenMap?: Record<string, EventTiming>;
+    /**
+     * Allows supplying institution-specific event clock anchors so parsed
+     * EventTiming arrays can be ordered chronologically for that locale.
+     */
+    eventClock?: EventClockMap;
     allowDiscouraged?: boolean;
-    locale?: "en" | "th" | string;
     /**
      * When enabled the parser will expand generic meal timing tokens (AC/PC/C)
      * into specific breakfast/lunch/dinner (and bedtime) EventTiming entries
@@ -311,6 +320,11 @@ export interface ParseOptions {
      * Defaults to "breakfast+dinner" to mirror common clinical practice.
      */
     twoPerDayPair?: "breakfast+dinner" | "breakfast+lunch";
+    /**
+     * Allows disabling recognition of household volume units such as teaspoon
+     * and tablespoon when set to false. Defaults to true.
+     */
+    allowHouseholdVolumeUnits?: boolean;
 }
 export interface ParseResult {
     fhir: FhirDosage;
@@ -348,17 +362,21 @@ export interface FrequencyFallbackTimes {
  * Shared configuration required to generate next-due dose timestamps.
  */
 export interface NextDueDoseConfig {
-    timeZone: string;
-    eventClock: EventClockMap;
-    mealOffsets: MealOffsetMap;
+    timeZone?: string;
+    eventClock?: EventClockMap;
+    mealOffsets?: MealOffsetMap;
     frequencyDefaults?: FrequencyFallbackTimes;
 }
 /**
  * Options bag for next-due dose generation.
  */
 export interface NextDueDoseOptions {
-    orderedAt: Date | string;
     from: Date | string;
-    limit: number;
-    config: NextDueDoseConfig;
+    orderedAt?: Date | string;
+    limit?: number;
+    timeZone?: string;
+    eventClock?: EventClockMap;
+    mealOffsets?: MealOffsetMap;
+    frequencyDefaults?: FrequencyFallbackTimes;
+    config?: NextDueDoseConfig;
 }

package/dist/types.js

@@ -1,8 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RouteCode = exports.FhirDayOfWeek = exports.FhirPeriodUnit = exports.SNOMEDCTRouteCodes = exports.EventTiming = void 0;
 /**
  * Follows https://build.fhir.org/valueset-event-timing.html
  * Real-world event relating to the schedule.
  */
-export var EventTiming;
+var EventTiming;
 (function (EventTiming) {
     EventTiming["Before Sleep"] = "HS";
     EventTiming["Wake"] = "WAKE";
@@ -31,12 +34,12 @@ export var EventTiming;
     EventTiming["Night"] = "NIGHT";
     EventTiming["After Sleep"] = "PHS";
     EventTiming["Immediate"] = "IMD";
-})(EventTiming || (EventTiming = {}));
+})(EventTiming || (exports.EventTiming = EventTiming = {}));
 /**
  * SNOMED CT route codes aligned with the official "route of administration values" value set.
  * Keeping the enumeration exhaustive ensures downstream consumers can rely on strong typing.
  */
-export var SNOMEDCTRouteCodes;
+var SNOMEDCTRouteCodes;
 (function (SNOMEDCTRouteCodes) {
     SNOMEDCTRouteCodes["Topical route"] = "6064005";
     SNOMEDCTRouteCodes["Otic route"] = "10547007";
@@ -201,8 +204,8 @@ export var SNOMEDCTRouteCodes;
     SNOMEDCTRouteCodes["Posterior juxtascleral route (qualifier value)"] = "58821000052106";
     SNOMEDCTRouteCodes["Subretinal route (qualifier value)"] = "58831000052108";
     SNOMEDCTRouteCodes["Sublabial use"] = "66621000052103";
-})(SNOMEDCTRouteCodes || (SNOMEDCTRouteCodes = {}));
-export var FhirPeriodUnit;
+})(SNOMEDCTRouteCodes || (exports.SNOMEDCTRouteCodes = SNOMEDCTRouteCodes = {}));
+var FhirPeriodUnit;
 (function (FhirPeriodUnit) {
     FhirPeriodUnit["Second"] = "s";
     FhirPeriodUnit["Minute"] = "min";
@@ -211,8 +214,8 @@ export var FhirPeriodUnit;
     FhirPeriodUnit["Week"] = "wk";
     FhirPeriodUnit["Month"] = "mo";
     FhirPeriodUnit["Year"] = "a";
-})(FhirPeriodUnit || (FhirPeriodUnit = {}));
-export var FhirDayOfWeek;
+})(FhirPeriodUnit || (exports.FhirPeriodUnit = FhirPeriodUnit = {}));
+var FhirDayOfWeek;
 (function (FhirDayOfWeek) {
     FhirDayOfWeek["Monday"] = "mon";
     FhirDayOfWeek["Tuesday"] = "tue";
@@ -221,5 +224,5 @@ export var FhirDayOfWeek;
     FhirDayOfWeek["Friday"] = "fri";
     FhirDayOfWeek["Saturday"] = "sat";
     FhirDayOfWeek["Sunday"] = "sun";
-})(FhirDayOfWeek || (FhirDayOfWeek = {}));
-export const RouteCode = SNOMEDCTRouteCodes;
+})(FhirDayOfWeek || (exports.FhirDayOfWeek = FhirDayOfWeek = {}));
+exports.RouteCode = SNOMEDCTRouteCodes;