ezmedicationinput 0.1.27 → 0.1.28

package/dist/format.js

@@ -587,6 +587,7 @@ function formatLong(internal) {
     const frequencyPart = describeFrequency(internal);
     const eventParts = collectWhenPhrases(internal);
     if ((_b = internal.timeOfDay) === null || _b === void 0 ? void 0 : _b.length) {
+        const timeStrings = [];
         for (const time of internal.timeOfDay) {
             const parts = time.split(":");
             const h = parseInt(parts[0], 10);
@@ -594,7 +595,10 @@ function formatLong(internal) {
             const isAm = h < 12;
             const displayH = h % 12 || 12;
             const displayM = m < 10 ? `0${m}` : `${m}`;
-            eventParts.push(`at ${displayH}:${displayM}${isAm ? " am" : " pm"}`);
+            timeStrings.push(`${displayH}:${displayM}${isAm ? " am" : " pm"}`);
+        }
+        if (timeStrings.length > 0) {
+            eventParts.push(`at ${timeStrings.join(", ")}`);
         }
     }
     const timing = combineFrequencyAndEvents(frequencyPart, eventParts);

package/dist/i18n.js

@@ -116,6 +116,16 @@ const WHEN_TEXT_THAI = {
     [types_1.EventTiming["After Sleep"]]: "หลังจากนอน",
     [types_1.EventTiming.Immediate]: "ทันที"
 };
+const INSTRUCTION_TEXT_THAI = {
+    "Take with or after food": "รับประทานพร้อมหรือหลังอาหาร",
+    "With or after food": "พร้อมหรือหลังอาหาร",
+    "Take before food": "รับประทานก่อนอาหาร",
+    "Take on an empty stomach": "รับประทานขณะท้องว่าง",
+    "Take with plenty of water": "รับประทานพร้อมน้ำดื่มจำนวนมาก",
+    "Dissolve or mix with water before taking": "ละลายหรือผสมน้ำก่อนรับประทาน",
+    "Avoid alcoholic drinks": "หลีกเลี่ยงเครื่องดื่มแอลกอฮอล์",
+    "May cause drowsiness; do not drive if affected": "อาจทำให้ง่วงซึม; ห้ามขับขี่ยานพาหนะหรือทำงานกับเครื่องจักรหากมีอาการ",
+};
 const DAY_NAMES_THAI = {
     mon: "วันจันทร์",
     tue: "วันอังคาร",
@@ -634,6 +644,7 @@ function formatAsNeededThai(internal) {
     return "ใช้เมื่อจำเป็น";
 }
 function formatShortThai(internal) {
+    var _a;
     const parts = [];
     const dose = formatDoseThaiShort(internal);
     if (dose) {
@@ -671,6 +682,10 @@ function formatShortThai(internal) {
             parts.push(events.join(" "));
         }
     }
+    if ((_a = internal.timeOfDay) === null || _a === void 0 ? void 0 : _a.length) {
+        const times = internal.timeOfDay.map((t) => t.slice(0, 5)).join(",");
+        parts.push(times);
+    }
     if (internal.dayOfWeek.length) {
         const days = internal.dayOfWeek
             .map((d) => { var _a, _b; return (_b = (_a = DAY_NAMES_THAI[d]) === null || _a === void 0 ? void 0 : _a.replace(/^วัน/, "")) !== null && _b !== void 0 ? _b : d; })
@@ -687,13 +702,27 @@ function formatShortThai(internal) {
     return parts.filter(Boolean).join(" ");
 }
 function formatLongThai(internal) {
-    var _a;
+    var _a, _b;
     const grammar = resolveRouteGrammarThai(internal);
     const dosePart = (_a = formatDoseThaiLong(internal)) !== null && _a !== void 0 ? _a : "ยา";
     const sitePart = formatSiteThai(internal, grammar);
     const routePart = buildRoutePhraseThai(internal, grammar, Boolean(sitePart));
     const frequencyPart = describeFrequencyThai(internal);
     const eventParts = collectWhenPhrasesThai(internal);
+    if ((_b = internal.timeOfDay) === null || _b === void 0 ? void 0 : _b.length) {
+        const timeStrings = [];
+        for (const time of internal.timeOfDay) {
+            const parts = time.split(":");
+            const h = parseInt(parts[0], 10);
+            const m = parseInt(parts[1], 10);
+            const displayM = m < 10 ? `0${m}` : `${m}`;
+            const displayH = h < 10 ? `0${h}` : `${h}`;
+            timeStrings.push(`${displayH}:${displayM}`);
+        }
+        if (timeStrings.length > 0) {
+            eventParts.push(`เวลา ${timeStrings.join(", ")}`);
+        }
+    }
     const timing = combineFrequencyAndEventsThai(frequencyPart, eventParts);
     const dayPart = describeDayOfWeekThai(internal);
     const countPart = internal.count !== undefined
@@ -724,9 +753,40 @@ function formatLongThai(internal) {
     }
     const body = segments.filter(Boolean).join(" ").replace(/\s+/g, " ").trim();
     if (!body) {
-        return `${grammar.verb}.`;
+        const instructionText = formatAdditionalInstructionsThai(internal);
+        if (!instructionText) {
+            return `${grammar.verb}.`;
+        }
+        return `${grammar.verb}. ${instructionText}`.trim();
+    }
+    const instructionText = formatAdditionalInstructionsThai(internal);
+    const baseSentence = `${grammar.verb} ${body}.`;
+    return instructionText ? `${baseSentence} ${instructionText}` : baseSentence;
+}
+function formatAdditionalInstructionsThai(internal) {
+    var _a;
+    if (!((_a = internal.additionalInstructions) === null || _a === void 0 ? void 0 : _a.length)) {
+        return undefined;
+    }
+    const phrases = internal.additionalInstructions
+        .map((instruction) => {
+        var _a;
+        const original = instruction.text || ((_a = instruction.coding) === null || _a === void 0 ? void 0 : _a.display);
+        if (!original)
+            return undefined;
+        const normalized = original.trim();
+        return INSTRUCTION_TEXT_THAI[normalized] || normalized;
+    })
+        .filter((text) => Boolean(text))
+        .map((text) => text.trim())
+        .filter((text) => text.length > 0);
+    if (!phrases.length) {
+        return undefined;
     }
-    return `${grammar.verb} ${body}.`;
+    return phrases
+        .map((phrase) => (/[.!?]$/.test(phrase) ? phrase : `${phrase}.`))
+        .join(" ")
+        .trim();
 }
 function stripTrailingZero(value) {
     const text = value.toString();

package/dist/maps.js

@@ -673,6 +673,9 @@ exports.EVENT_TIMING_TOKENS = {
     breakfast: types_1.EventTiming.Breakfast,
     bfast: types_1.EventTiming.Breakfast,
     brkfst: types_1.EventTiming.Breakfast,
+    meal: types_1.EventTiming.Meal,
+    meals: types_1.EventTiming.Meal,
+    food: types_1.EventTiming.Meal,
     brk: types_1.EventTiming.Breakfast,
     cd: types_1.EventTiming.Lunch,
     lunch: types_1.EventTiming.Lunch,
@@ -717,6 +720,10 @@ registerMealKeywords(["dinner", "dinnertime", "supper", "suppertime"], {
     pc: types_1.EventTiming["After Dinner"],
     ac: types_1.EventTiming["Before Dinner"]
 });
+registerMealKeywords(["meal", "meals", "food"], {
+    pc: types_1.EventTiming["After Meal"],
+    ac: types_1.EventTiming["Before Meal"]
+});
 exports.MEAL_KEYWORDS = (0, object_1.objectFromEntries)(MEAL_KEYWORD_ENTRIES);
 exports.DISCOURAGED_TOKENS = {
     qd: "QD",

package/dist/parser.js

@@ -781,15 +781,40 @@ function tryParseTimeBasedSchedule(internal, tokens, index) {
     const token = tokens[index];
     if (internal.consumed.has(token.index))
         return false;
-    const isAtPrefix = token.lower === "@" || token.lower === "at";
-    if (!isAtPrefix && !/^\d/.test(token.lower))
+    // Handle connectors like "and at" or just "and" before a time.
+    // This prevents rogue "and" from leaking into Additional Instructions
+    // when it serves as a connector between schedule parts.
+    let isAndPrefix = false;
+    let isAtPrefix = token.lower === "@" || token.lower === "at";
+    if (token.lower === "and" && !isAtPrefix) {
+        const next = tokens[index + 1];
+        if (next && !internal.consumed.has(next.index)) {
+            const nextLower = next.lower;
+            // If "and" is followed by "at", "@", or a number, it's a connector for this time block
+            if (nextLower === "@" || nextLower === "at" || /^\d/.test(nextLower)) {
+                isAndPrefix = true;
+                if (nextLower === "@" || nextLower === "at") {
+                    isAtPrefix = true;
+                }
+            }
+        }
+    }
+    if (!isAtPrefix && !isAndPrefix && !/^\d/.test(token.lower))
         return false;
-    let nextIndex = isAtPrefix ? index + 1 : index;
+    let nextIndex = index;
+    if (isAndPrefix)
+        nextIndex++;
+    if (isAtPrefix)
+        nextIndex++;
     const times = [];
     const consumedIndices = [];
     const timeTokens = [];
-    if (isAtPrefix)
+    if (isAndPrefix)
         consumedIndices.push(index);
+    if (isAtPrefix) {
+        // If we have "and at", at is the second token (index + 1)
+        consumedIndices.push(isAndPrefix ? index + 1 : index);
+    }
     while (nextIndex < tokens.length) {
         const nextToken = tokens[nextIndex];
         if (!nextToken || internal.consumed.has(nextToken.index))
@@ -1918,15 +1943,19 @@ function parseInternal(input, options) {
                 : types_1.EventTiming["Before Meal"]);
             continue;
         }
-        if (token.lower === "at" || token.lower === "@" || token.lower === "on") {
+        if (token.lower === "at" || token.lower === "@" || token.lower === "on" || token.lower === "with") {
             if (parseAnchorSequence(internal, tokens, i)) {
                 continue;
             }
             if (tryParseTimeBasedSchedule(internal, tokens, i)) {
                 continue;
             }
-            mark(internal.consumed, token);
-            continue;
+            // If none of the above consume it, and it's a known anchor prefix, mark it
+            // but only if it's not "with" which might be part of other phrases later.
+            if (token.lower !== "with") {
+                mark(internal.consumed, token);
+                continue;
+            }
         }
         const nextToken = tokens[i + 1];
         if (nextToken && !internal.consumed.has(nextToken.index)) {
@@ -1938,12 +1967,6 @@ function parseInternal(input, options) {
                 mark(internal.consumed, nextToken);
                 continue;
             }
-            // Issue 2: Support "with meal" and "with food" combos explicitly if needed
-            if (token.lower === "with" && (lowerNext === "meal" || lowerNext === "food")) {
-                applyWhenToken(internal, token, types_1.EventTiming.Meal);
-                mark(internal.consumed, nextToken);
-                continue;
-            }
         }
         const customWhen = (_g = options === null || options === void 0 ? void 0 : options.whenMap) === null || _g === void 0 ? void 0 : _g[token.lower];
         if (customWhen) {
@@ -2813,12 +2836,12 @@ function findAdditionalInstructionDefinition(text, canonical) {
         if (!entry.canonical) {
             continue;
         }
+        // Check for exact canonical match first
         if (entry.canonical === canonical) {
             return entry.definition;
         }
-        if (canonical.includes(entry.canonical) || entry.canonical.includes(canonical)) {
-            return entry.definition;
-        }
+        // Avoid broad includes checks (like "with" matching "with meal") 
+        // to prevent leakage of common connectors into additional instructions.
         for (const term of entry.terms) {
             const normalizedTerm = (0, maps_1.normalizeAdditionalInstructionKey)(term);
             if (!normalizedTerm) {

package/dist/suggest.js

@@ -347,6 +347,43 @@ function canonicalizeLowercaseForMatching(value) {
 function canonicalizeForMatching(value) {
     return canonicalizeLowercaseForMatching(value.toLowerCase());
 }
+function buildTimeTokens(input) {
+    const tokens = new Set();
+    // Add common times
+    for (let i = 1; i <= 12; i++) {
+        tokens.add(`at ${i}:00 am`);
+        tokens.add(`at ${i}:00 pm`);
+    }
+    // Analyze input for specific time requests to provide more granular suggestions
+    const match = input.match(/(?:at|@)\s*(\d{1,2})(?::(\d{0,2}))?/i);
+    if (match) {
+        const h = parseInt(match[1], 10);
+        if (h >= 1 && h <= 12) {
+            const m = match[2] || "00";
+            if (m.length === 1) {
+                tokens.add(`at ${h}:${m}0 am`);
+                tokens.add(`at ${h}:${m}0 pm`);
+            }
+            else {
+                tokens.add(`at ${h}:${m} am`);
+                tokens.add(`at ${h}:${m} pm`);
+            }
+        }
+        else if (h > 12 && h < 24) {
+            // Input seems to be 24h, but we format as am/pm usually.
+            // Let's add the 24h format as well if that's what they are typing?
+            // Or convert to am/pm? Let's add both for robustness.
+            const m = match[2] || "00";
+            if (m.length === 1) {
+                tokens.add(`at ${h}:${m}0`);
+            }
+            else {
+                tokens.add(`at ${h}:${m}`);
+            }
+        }
+    }
+    return [...tokens];
+}
 function tokensMatch(prefixTokens, candidateTokens) {
     if (prefixTokens.length === 0) {
         return true;
@@ -461,7 +498,7 @@ function getCandidateFingerprint(candidateLower) {
     }
     return fingerprint;
 }
-function generateCandidateDirections(pairs, doseValues, prnReasons, intervalTokens, whenSequences, limit, matcher) {
+function generateCandidateDirections(pairs, doseValues, prnReasons, intervalTokens, timeTokens, whenSequences, limit, matcher) {
     const suggestions = [];
     const seen = new Set();
     const doseVariantMap = new Map();
@@ -502,6 +539,7 @@ function generateCandidateDirections(pairs, doseValues, prnReasons, intervalToke
     const whenSuffixes = whenSequences === PRECOMPUTED_WHEN_SEQUENCES
         ? PRECOMPUTED_WHEN_SEQUENCE_SUFFIXES
         : whenSequences.map((sequence) => ` ${sequence.join(" ")}`);
+    const timeSuffixes = timeTokens.map((token) => ` ${token}`);
     for (let pairIndex = 0; pairIndex < pairs.length; pairIndex += 1) {
         const pair = pairs[pairIndex];
         const unitVariants = getUnitVariants(pair.unit);
@@ -593,6 +631,21 @@ function generateCandidateDirections(pairs, doseValues, prnReasons, intervalToke
                 return suggestions;
             }
         }
+        for (let timeIndex = 0; timeIndex < timeSuffixes.length; timeIndex += 1) {
+            const timeSuffix = timeSuffixes[timeIndex];
+            for (let unitIndex = 0; unitIndex < unitDoseVariants.length; unitIndex += 1) {
+                const doseBases = unitDoseVariants[unitIndex];
+                for (let doseIndex = 0; doseIndex < doseBases.length; doseIndex += 1) {
+                    const base = doseBases[doseIndex];
+                    if (push(base.value + timeSuffix, base.lower + timeSuffix)) {
+                        return suggestions;
+                    }
+                }
+            }
+            if (push(route + timeSuffix, routeLower + timeSuffix)) {
+                return suggestions;
+            }
+        }
         for (let reasonIndex = 0; reasonIndex < prnSuffixes.length; reasonIndex += 1) {
             const reasonSuffix = prnSuffixes[reasonIndex];
             for (let unitIndex = 0; unitIndex < unitDoseVariants.length; unitIndex += 1) {
@@ -712,7 +765,8 @@ function suggestSig(input, options) {
     const doseValues = buildDoseValues(input);
     const prnReasons = buildPrnReasons(options === null || options === void 0 ? void 0 : options.prnReasons);
     const intervalTokens = buildIntervalTokens(input);
+    const timeTokens = buildTimeTokens(input);
     const whenSequences = PRECOMPUTED_WHEN_SEQUENCES;
     const matcher = (candidate, candidateLower) => matchesPrefix(candidate, candidateLower, prefixContext);
-    return generateCandidateDirections(pairs, doseValues, prnReasons, intervalTokens, whenSequences, limit, matcher);
+    return generateCandidateDirections(pairs, doseValues, prnReasons, intervalTokens, timeTokens, whenSequences, limit, matcher);
 }

package/package.json

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