ezmedicationinput 0.1.3 → 0.1.6

package/dist/parser.js

@@ -110,6 +110,7 @@ const COMBO_EVENT_TIMINGS = {
     "after sleep": types_1.EventTiming["After Sleep"],
     "upon waking": types_1.EventTiming.Wake
 };
+const MEAL_CONTEXT_CONNECTORS = new Set(["and", "or", "&", "+", "plus"]);
 // Tracking explicit breakfast/lunch/dinner markers lets the meal-expansion
 // logic bail early when the clinician already specified precise events.
 const SPECIFIC_MEAL_TIMINGS = new Set([
@@ -976,20 +977,31 @@ function applyWhenToken(internal, token, code) {
 }
 function parseMealContext(internal, tokens, index, code) {
     const token = tokens[index];
-    const next = tokens[index + 1];
-    if (!next || internal.consumed.has(next.index)) {
-        applyWhenToken(internal, token, code);
-        return;
-    }
-    const meal = maps_1.MEAL_KEYWORDS[next.lower];
-    if (meal) {
+    let converted = 0;
+    for (let lookahead = index + 1; lookahead < tokens.length; lookahead++) {
+        const nextToken = tokens[lookahead];
+        if (internal.consumed.has(nextToken.index)) {
+            continue;
+        }
+        if (MEAL_CONTEXT_CONNECTORS.has(nextToken.lower)) {
+            mark(internal.consumed, nextToken);
+            continue;
+        }
+        const meal = maps_1.MEAL_KEYWORDS[nextToken.lower];
+        if (!meal) {
+            break;
+        }
         const whenCode = code === types_1.EventTiming["After Meal"]
             ? meal.pc
             : code === types_1.EventTiming["Before Meal"]
                 ? meal.ac
                 : code;
-        applyWhenToken(internal, token, whenCode);
-        mark(internal.consumed, next);
+        addWhen(internal.when, whenCode);
+        mark(internal.consumed, nextToken);
+        converted++;
+    }
+    if (converted > 0) {
+        mark(internal.consumed, token);
         return;
     }
     applyWhenToken(internal, token, code);

package/dist/suggest.js

@@ -206,11 +206,40 @@ function normalizeSpacing(value) {
         .trim()
         .replace(/\s+/g, " ");
 }
+function removeWhitespaceCharacters(value) {
+    for (let index = 0; index < value.length; index += 1) {
+        const code = value.charCodeAt(index);
+        if (code <= 32) {
+            const result = [];
+            for (let inner = 0; inner < value.length; inner += 1) {
+                const currentCode = value.charCodeAt(inner);
+                if (currentCode > 32) {
+                    result.push(value.charAt(inner));
+                }
+            }
+            return result.join("");
+        }
+    }
+    return value;
+}
+function removeDashes(value) {
+    if (value.indexOf("-") === -1) {
+        return value;
+    }
+    const result = [];
+    for (let index = 0; index < value.length; index += 1) {
+        const char = value.charAt(index);
+        if (char !== "-") {
+            result.push(char);
+        }
+    }
+    return result.join("");
+}
 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 variants = new Map();
     const push = (candidate) => {
         if (!candidate) {
             return;
@@ -219,7 +248,11 @@ function getUnitVariants(unit) {
         if (!normalizedCandidate) {
             return;
         }
-        variants.add(normalizedCandidate);
+        const lower = normalizedCandidate.toLowerCase();
+        if (variants.has(lower)) {
+            return;
+        }
+        variants.set(lower, { value: normalizedCandidate, lower });
     };
     push(canonical);
     push(unit);
@@ -229,7 +262,7 @@ function getUnitVariants(unit) {
             push(candidate);
         }
     }
-    return [...variants];
+    return [...variants.values()];
 }
 function buildIntervalTokens(input) {
     const intervals = new Set();
@@ -288,16 +321,22 @@ function buildWhenSequences() {
     }
     return sequences;
 }
-function tokenizeForMatching(value) {
+const PRECOMPUTED_WHEN_SEQUENCES = buildWhenSequences();
+function tokenizeLowercaseForMatching(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 tokenizeForMatching(value) {
+    return tokenizeLowercaseForMatching(value.toLowerCase());
+}
+function canonicalizeLowercaseForMatching(value) {
+    return tokenizeLowercaseForMatching(value).join(" ");
+}
 function canonicalizeForMatching(value) {
-    return tokenizeForMatching(value).join(" ");
+    return canonicalizeLowercaseForMatching(value.toLowerCase());
 }
 function tokensMatch(prefixTokens, candidateTokens) {
     if (prefixTokens.length === 0) {
@@ -342,12 +381,13 @@ function buildUnitRoutePairs(contextUnit, options) {
         if (!cleanRoute) {
             return;
         }
-        const key = `${normalizedUnit}::${normalizeKey(cleanRoute)}`;
+        const routeLower = cleanRoute.toLowerCase();
+        const key = `${normalizedUnit}::${routeLower}`;
         if (seen.has(key)) {
             return;
         }
         seen.add(key);
-        pairs.push({ unit: canonicalUnit, route: cleanRoute });
+        pairs.push({ unit: canonicalUnit, route: cleanRoute, routeLower });
     };
     addPair(contextUnit);
     for (const preference of DEFAULT_UNIT_ROUTE_ORDER) {
@@ -403,133 +443,263 @@ function buildDoseValues(input) {
     }
     return [...values];
 }
-function generateCandidateDirections(pairs, doseValues, prnReasons, intervalTokens, whenSequences) {
+const CANDIDATE_FINGERPRINT_CACHE = new Map();
+function getCandidateFingerprint(candidateLower) {
+    let fingerprint = CANDIDATE_FINGERPRINT_CACHE.get(candidateLower);
+    if (!fingerprint) {
+        fingerprint = {};
+        CANDIDATE_FINGERPRINT_CACHE.set(candidateLower, fingerprint);
+    }
+    return fingerprint;
+}
+function generateCandidateDirections(pairs, doseValues, prnReasons, intervalTokens, whenSequences, limit, matcher) {
     const suggestions = [];
     const seen = new Set();
-    const push = (value) => {
-        const normalized = normalizeSpacing(value);
+    const doseVariantMap = new Map();
+    for (const dose of doseValues) {
+        const normalized = normalizeSpacing(dose);
         if (!normalized) {
-            return;
+            continue;
         }
-        const key = normalizeKey(normalized);
-        if (seen.has(key)) {
-            return;
+        const lower = normalized.toLowerCase();
+        if (!doseVariantMap.has(lower)) {
+            doseVariantMap.set(lower, { value: normalized, lower });
         }
-        seen.add(key);
-        suggestions.push(normalized);
+    }
+    const doseVariants = [...doseVariantMap.values()];
+    const push = (value, lower) => {
+        if (!lower) {
+            return false;
+        }
+        if (seen.has(lower)) {
+            return false;
+        }
+        if (!matcher(value, lower)) {
+            return false;
+        }
+        seen.add(lower);
+        suggestions.push(value);
+        return suggestions.length >= limit;
     };
     for (const pair of pairs) {
         const unitVariants = getUnitVariants(pair.unit);
+        const route = pair.route;
+        const routeLower = pair.routeLower;
         for (const code of FREQUENCY_CODES) {
+            const codeSuffix = ` ${code}`;
             for (const unitVariant of unitVariants) {
-                for (const dose of doseValues) {
-                    push(`${dose} ${unitVariant} ${pair.route} ${code}`);
+                const unitRoute = `${unitVariant.value} ${route}`;
+                const unitRouteLower = `${unitVariant.lower} ${routeLower}`;
+                for (const doseVariant of doseVariants) {
+                    const candidate = `${doseVariant.value} ${unitRoute}${codeSuffix}`;
+                    const candidateLower = `${doseVariant.lower} ${unitRouteLower}${codeSuffix}`;
+                    if (push(candidate, candidateLower)) {
+                        return suggestions;
+                    }
                 }
             }
-            push(`${pair.route} ${code}`);
+            const candidate = `${route}${codeSuffix}`;
+            const candidateLower = `${routeLower}${codeSuffix}`;
+            if (push(candidate, candidateLower)) {
+                return suggestions;
+            }
         }
         for (const interval of intervalTokens) {
+            const intervalSuffix = ` ${interval}`;
             for (const unitVariant of unitVariants) {
-                for (const dose of doseValues) {
-                    push(`${dose} ${unitVariant} ${pair.route} ${interval}`);
+                const unitRoute = `${unitVariant.value} ${route}`;
+                const unitRouteLower = `${unitVariant.lower} ${routeLower}`;
+                for (const doseVariant of doseVariants) {
+                    const base = `${doseVariant.value} ${unitRoute}`;
+                    const baseLower = `${doseVariant.lower} ${unitRouteLower}`;
+                    const intervalCandidate = `${base}${intervalSuffix}`;
+                    const intervalCandidateLower = `${baseLower}${intervalSuffix}`;
+                    if (push(intervalCandidate, intervalCandidateLower)) {
+                        return suggestions;
+                    }
                     for (const reason of prnReasons) {
-                        push(`${dose} ${unitVariant} ${pair.route} ${interval} prn ${reason}`);
+                        const reasonSuffix = `${intervalSuffix} prn ${reason}`;
+                        const reasonCandidate = `${base}${reasonSuffix}`;
+                        const reasonCandidateLower = `${baseLower}${reasonSuffix}`;
+                        if (push(reasonCandidate, reasonCandidateLower)) {
+                            return suggestions;
+                        }
                     }
                 }
             }
-            push(`${pair.route} ${interval}`);
+            const candidate = `${route}${intervalSuffix}`;
+            const candidateLower = `${routeLower}${intervalSuffix}`;
+            if (push(candidate, candidateLower)) {
+                return suggestions;
+            }
         }
         for (const freq of FREQUENCY_NUMBERS) {
             const freqToken = FREQ_TOKEN_BY_NUMBER[freq];
             if (!freqToken) {
                 continue;
             }
-            push(`1x${freq} ${pair.route} ${freqToken}`);
+            const base = `1x${freq} ${route}`;
+            const baseLower = `1x${freq} ${routeLower}`;
+            const freqCandidate = `${base} ${freqToken}`;
+            const freqCandidateLower = `${baseLower} ${freqToken}`;
+            if (push(freqCandidate, freqCandidateLower)) {
+                return suggestions;
+            }
             for (const when of CORE_WHEN_TOKENS) {
-                push(`1x${freq} ${pair.route} ${when}`);
+                const whenCandidate = `${base} ${when}`;
+                const whenCandidateLower = `${baseLower} ${when}`;
+                if (push(whenCandidate, whenCandidateLower)) {
+                    return suggestions;
+                }
             }
         }
         for (const whenSequence of whenSequences) {
-            const suffix = whenSequence.join(" ");
+            const suffix = ` ${whenSequence.join(" ")}`;
             for (const unitVariant of unitVariants) {
-                for (const dose of doseValues) {
-                    push(`${dose} ${unitVariant} ${pair.route} ${suffix}`);
+                const unitRoute = `${unitVariant.value} ${route}`;
+                const unitRouteLower = `${unitVariant.lower} ${routeLower}`;
+                for (const doseVariant of doseVariants) {
+                    const base = `${doseVariant.value} ${unitRoute}`;
+                    const baseLower = `${doseVariant.lower} ${unitRouteLower}`;
+                    const candidate = `${base}${suffix}`;
+                    const candidateLower = `${baseLower}${suffix}`;
+                    if (push(candidate, candidateLower)) {
+                        return suggestions;
+                    }
                 }
             }
-            push(`${pair.route} ${suffix}`);
+            const candidate = `${route}${suffix}`;
+            const candidateLower = `${routeLower}${suffix}`;
+            if (push(candidate, candidateLower)) {
+                return suggestions;
+            }
         }
         for (const reason of prnReasons) {
+            const reasonSuffix = ` prn ${reason}`;
             for (const unitVariant of unitVariants) {
-                for (const dose of doseValues) {
-                    push(`${dose} ${unitVariant} ${pair.route} prn ${reason}`);
+                const unitRoute = `${unitVariant.value} ${route}`;
+                const unitRouteLower = `${unitVariant.lower} ${routeLower}`;
+                for (const doseVariant of doseVariants) {
+                    const base = `${doseVariant.value} ${unitRoute}`;
+                    const baseLower = `${doseVariant.lower} ${unitRouteLower}`;
+                    const candidate = `${base}${reasonSuffix}`;
+                    const candidateLower = `${baseLower}${reasonSuffix}`;
+                    if (push(candidate, candidateLower)) {
+                        return suggestions;
+                    }
                 }
             }
-            push(`${pair.route} prn ${reason}`);
+            const candidate = `${route}${reasonSuffix}`;
+            const candidateLower = `${routeLower}${reasonSuffix}`;
+            if (push(candidate, candidateLower)) {
+                return suggestions;
+            }
         }
     }
     return suggestions;
 }
-function matchesPrefix(candidate, prefix, prefixCompact, prefixTokens, prefixTokensNoDashes, prefixCanonical, prefixCanonicalCompact, prefixNoDashes, prefixCanonicalNoDashes) {
-    if (!prefix) {
+function matchesPrefix(_candidate, candidateLower, context) {
+    var _a, _b, _c, _d, _e, _f;
+    if (!context.raw) {
         return true;
     }
-    const normalizedCandidate = candidate.toLowerCase();
-    if (normalizedCandidate.startsWith(prefix)) {
+    if (!context.hasCanonical && !context.hasTokens) {
         return true;
     }
-    const compactCandidate = normalizedCandidate.replace(/\s+/g, "");
-    if (compactCandidate.startsWith(prefixCompact)) {
+    if (candidateLower.startsWith(context.raw)) {
         return true;
     }
-    const candidateNoDashes = normalizedCandidate.replace(/-/g, "");
-    if (candidateNoDashes.startsWith(prefixNoDashes)) {
-        return true;
+    const fingerprint = getCandidateFingerprint(candidateLower);
+    if (context.requiresCompact) {
+        const compactCandidate = (_a = fingerprint.compact) !== null && _a !== void 0 ? _a : (fingerprint.compact = removeWhitespaceCharacters(candidateLower));
+        if (compactCandidate.startsWith(context.compact)) {
+            return true;
+        }
     }
-    const canonicalCandidate = canonicalizeForMatching(candidate);
-    if (canonicalCandidate.startsWith(prefixCanonical)) {
-        return true;
+    if (context.requiresNoDashes) {
+        const candidateNoDashes = (_b = fingerprint.noDashes) !== null && _b !== void 0 ? _b : (fingerprint.noDashes = removeDashes(candidateLower));
+        if (candidateNoDashes.startsWith(context.noDashes)) {
+            return true;
+        }
     }
-    const canonicalCompact = canonicalCandidate.replace(/\s+/g, "");
-    if (canonicalCompact.startsWith(prefixCanonicalCompact)) {
-        return true;
+    const getCandidateTokens = () => {
+        if (!fingerprint.tokens) {
+            fingerprint.tokens = tokenizeLowercaseForMatching(candidateLower);
+        }
+        return fingerprint.tokens;
+    };
+    if (context.hasCanonical) {
+        const canonicalCandidate = (_c = fingerprint.canonical) !== null && _c !== void 0 ? _c : (fingerprint.canonical = getCandidateTokens().join(" "));
+        if (canonicalCandidate.startsWith(context.canonical)) {
+            return true;
+        }
+        if (context.requiresCanonicalCompact) {
+            const canonicalCompact = (_d = fingerprint.canonicalCompact) !== null && _d !== void 0 ? _d : (fingerprint.canonicalCompact = removeWhitespaceCharacters(canonicalCandidate));
+            if (canonicalCompact.startsWith(context.canonicalCompact)) {
+                return true;
+            }
+        }
+        if (context.requiresCanonicalNoDashes) {
+            const canonicalNoDashes = (_e = fingerprint.canonicalNoDashes) !== null && _e !== void 0 ? _e : (fingerprint.canonicalNoDashes = removeDashes(canonicalCandidate));
+            if (canonicalNoDashes.startsWith(context.canonicalNoDashes)) {
+                return true;
+            }
+        }
     }
-    const candidateTokens = tokenizeForMatching(candidate);
-    if (tokensMatch(prefixTokens, candidateTokens)) {
-        return true;
+    if (context.hasTokens) {
+        const resolvedTokens = getCandidateTokens();
+        if (tokensMatch(context.tokens, resolvedTokens)) {
+            return true;
+        }
+        if (context.requiresTokenNoDashes) {
+            const candidateTokensNoDashes = (_f = fingerprint.tokensNoDashes) !== null && _f !== void 0 ? _f : (fingerprint.tokensNoDashes = resolvedTokens.map((token) => removeDashes(token)));
+            if (tokensMatch(context.tokensNoDashes, candidateTokensNoDashes)) {
+                return true;
+            }
+        }
     }
-    const canonicalNoDashes = canonicalCandidate.replace(/-/g, "");
-    if (canonicalNoDashes.startsWith(prefixCanonicalNoDashes)) {
+    else if (context.requiresTokenNoDashes) {
         return true;
     }
-    const candidateTokensNoDashes = candidateTokens.map((token) => token.replace(/-/g, ""));
-    return tokensMatch(prefixTokensNoDashes, candidateTokensNoDashes);
+    return false;
 }
 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;
+    if (limit <= 0) {
+        return [];
+    }
     const prefix = normalizeSpacing(input.toLowerCase());
     const prefixCompact = prefix.replace(/\s+/g, "");
     const prefixNoDashes = prefix.replace(/-/g, "");
-    const prefixCanonical = canonicalizeForMatching(prefix);
+    const prefixTokens = tokenizeLowercaseForMatching(prefix);
+    const prefixCanonical = prefixTokens.join(" ");
     const prefixCanonicalCompact = prefixCanonical.replace(/\s+/g, "");
     const prefixCanonicalNoDashes = prefixCanonical.replace(/-/g, "");
-    const prefixTokens = tokenizeForMatching(prefixCanonical);
     const prefixTokensNoDashes = prefixTokens.map((token) => token.replace(/-/g, ""));
+    const prefixContext = {
+        raw: prefix,
+        compact: prefixCompact,
+        noDashes: prefixNoDashes,
+        canonical: prefixCanonical,
+        canonicalCompact: prefixCanonicalCompact,
+        canonicalNoDashes: prefixCanonicalNoDashes,
+        tokens: prefixTokens,
+        tokensNoDashes: prefixTokensNoDashes,
+        hasCanonical: prefixCanonical.length > 0,
+        hasTokens: prefixTokens.length > 0,
+        requiresCompact: prefixCompact !== prefix,
+        requiresNoDashes: prefixNoDashes !== prefix,
+        requiresCanonicalCompact: prefixCanonicalCompact !== prefixCanonical,
+        requiresCanonicalNoDashes: prefixCanonicalNoDashes !== prefixCanonical,
+        requiresTokenNoDashes: prefixTokens.some((token, index) => token !== prefixTokensNoDashes[index]),
+    };
     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 === 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, prefixTokens, prefixTokensNoDashes, prefixCanonical, prefixCanonicalCompact, prefixNoDashes, prefixCanonicalNoDashes)) {
-            results.push(candidate);
-        }
-        if (results.length >= limit) {
-            break;
-        }
-    }
-    return results;
+    const whenSequences = PRECOMPUTED_WHEN_SEQUENCES;
+    const matcher = (candidate, candidateLower) => matchesPrefix(candidate, candidateLower, prefixContext);
+    return generateCandidateDirections(pairs, doseValues, prnReasons, intervalTokens, whenSequences, limit, matcher);
 }

package/package.json

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