ezmedicationinput 0.1.5 → 0.1.7

package/dist/suggest.js

@@ -105,6 +105,7 @@ const WHEN_COMBINATIONS = [
 ].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 FREQUENCY_CODE_SUFFIXES = FREQUENCY_CODES.map((code) => ` ${code}`);
 const FREQ_TOKEN_BY_NUMBER = {};
 for (const [frequency, token] of [
     [1, "qd"],
@@ -206,11 +207,45 @@ 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("");
+}
+const UNIT_VARIANT_CACHE = new Map();
 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 cached = UNIT_VARIANT_CACHE.get(normalizedCanonical);
+    if (cached) {
+        return cached;
+    }
+    const variants = new Map();
     const push = (candidate) => {
         if (!candidate) {
             return;
@@ -219,7 +254,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 +268,9 @@ function getUnitVariants(unit) {
             push(candidate);
         }
     }
-    return [...variants];
+    const result = [...variants.values()];
+    UNIT_VARIANT_CACHE.set(normalizedCanonical, result);
+    return result;
 }
 function buildIntervalTokens(input) {
     const intervals = new Set();
@@ -289,16 +330,22 @@ function buildWhenSequences() {
     return sequences;
 }
 const PRECOMPUTED_WHEN_SEQUENCES = buildWhenSequences();
-function tokenizeForMatching(value) {
+const PRECOMPUTED_WHEN_SEQUENCE_SUFFIXES = PRECOMPUTED_WHEN_SEQUENCES.map((sequence) => ` ${sequence.join(" ")}`);
+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) {
@@ -343,12 +390,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) {
@@ -404,132 +452,229 @@ function buildDoseValues(input) {
     }
     return [...values];
 }
+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) {
+            continue;
+        }
+        const lower = normalized.toLowerCase();
+        if (!doseVariantMap.has(lower)) {
+            doseVariantMap.set(lower, { value: normalized, lower });
+        }
+    }
+    const doseVariants = [...doseVariantMap.values()];
+    const push = (value, lower) => {
+        if (!lower) {
             return false;
         }
-        const key = normalizeKey(normalized);
-        if (seen.has(key)) {
+        if (seen.has(lower)) {
             return false;
         }
-        seen.add(key);
-        if (!matcher(normalized)) {
+        if (!matcher(value, lower)) {
             return false;
         }
-        suggestions.push(normalized);
+        seen.add(lower);
+        suggestions.push(value);
         return suggestions.length >= limit;
     };
-    for (const pair of pairs) {
+    const codeSuffixes = FREQUENCY_CODE_SUFFIXES;
+    const prnSuffixes = new Array(prnReasons.length);
+    for (let i = 0; i < prnReasons.length; i += 1) {
+        prnSuffixes[i] = ` prn ${prnReasons[i]}`;
+    }
+    const intervalSuffixes = new Array(intervalTokens.length);
+    for (let i = 0; i < intervalTokens.length; i += 1) {
+        intervalSuffixes[i] = ` ${intervalTokens[i]}`;
+    }
+    const whenSuffixes = whenSequences === PRECOMPUTED_WHEN_SEQUENCES
+        ? PRECOMPUTED_WHEN_SEQUENCE_SUFFIXES
+        : whenSequences.map((sequence) => ` ${sequence.join(" ")}`);
+    for (let pairIndex = 0; pairIndex < pairs.length; pairIndex += 1) {
+        const pair = pairs[pairIndex];
         const unitVariants = getUnitVariants(pair.unit);
-        for (const code of FREQUENCY_CODES) {
-            for (const unitVariant of unitVariants) {
-                for (const dose of doseValues) {
-                    if (push(`${dose} ${unitVariant} ${pair.route} ${code}`)) {
+        const route = pair.route;
+        const routeLower = pair.routeLower;
+        const unitDoseVariants = new Array(unitVariants.length);
+        for (let unitIndex = 0; unitIndex < unitVariants.length; unitIndex += 1) {
+            const unitVariant = unitVariants[unitIndex];
+            const unitRouteValue = `${unitVariant.value} ${route}`;
+            const unitRouteLower = `${unitVariant.lower} ${routeLower}`;
+            const doseBases = new Array(doseVariants.length);
+            for (let doseIndex = 0; doseIndex < doseVariants.length; doseIndex += 1) {
+                const doseVariant = doseVariants[doseIndex];
+                doseBases[doseIndex] = {
+                    value: `${doseVariant.value} ${unitRouteValue}`,
+                    lower: `${doseVariant.lower} ${unitRouteLower}`,
+                };
+            }
+            unitDoseVariants[unitIndex] = doseBases;
+        }
+        for (let codeIndex = 0; codeIndex < codeSuffixes.length; codeIndex += 1) {
+            const codeSuffix = codeSuffixes[codeIndex];
+            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 + codeSuffix, base.lower + codeSuffix)) {
                         return suggestions;
                     }
                 }
             }
-            if (push(`${pair.route} ${code}`)) {
+            if (push(route + codeSuffix, routeLower + codeSuffix)) {
                 return suggestions;
             }
         }
-        for (const interval of intervalTokens) {
-            for (const unitVariant of unitVariants) {
-                for (const dose of doseValues) {
-                    if (push(`${dose} ${unitVariant} ${pair.route} ${interval}`)) {
+        for (let intervalIndex = 0; intervalIndex < intervalSuffixes.length; intervalIndex += 1) {
+            const intervalSuffix = intervalSuffixes[intervalIndex];
+            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];
+                    const baseIntervalValue = base.value + intervalSuffix;
+                    const baseIntervalLower = base.lower + intervalSuffix;
+                    if (push(baseIntervalValue, baseIntervalLower)) {
                         return suggestions;
                     }
-                    for (const reason of prnReasons) {
-                        if (push(`${dose} ${unitVariant} ${pair.route} ${interval} prn ${reason}`)) {
+                    for (let reasonIndex = 0; reasonIndex < prnSuffixes.length; reasonIndex += 1) {
+                        const reasonSuffix = prnSuffixes[reasonIndex];
+                        if (push(baseIntervalValue + reasonSuffix, baseIntervalLower + reasonSuffix)) {
                             return suggestions;
                         }
                     }
                 }
             }
-            if (push(`${pair.route} ${interval}`)) {
+            if (push(route + intervalSuffix, routeLower + intervalSuffix)) {
                 return suggestions;
             }
         }
-        for (const freq of FREQUENCY_NUMBERS) {
+        for (let freqIndex = 0; freqIndex < FREQUENCY_NUMBERS.length; freqIndex += 1) {
+            const freq = FREQUENCY_NUMBERS[freqIndex];
             const freqToken = FREQ_TOKEN_BY_NUMBER[freq];
             if (!freqToken) {
                 continue;
             }
-            if (push(`1x${freq} ${pair.route} ${freqToken}`)) {
+            const baseValue = `1x${freq} ${route}`;
+            const baseLower = `1x${freq} ${routeLower}`;
+            if (push(`${baseValue} ${freqToken}`, `${baseLower} ${freqToken}`)) {
                 return suggestions;
             }
-            for (const when of CORE_WHEN_TOKENS) {
-                if (push(`1x${freq} ${pair.route} ${when}`)) {
+            for (let whenIndex = 0; whenIndex < CORE_WHEN_TOKENS.length; whenIndex += 1) {
+                const whenToken = CORE_WHEN_TOKENS[whenIndex];
+                if (push(`${baseValue} ${whenToken}`, `${baseLower} ${whenToken}`)) {
                     return suggestions;
                 }
             }
         }
-        for (const whenSequence of whenSequences) {
-            const suffix = whenSequence.join(" ");
-            for (const unitVariant of unitVariants) {
-                for (const dose of doseValues) {
-                    if (push(`${dose} ${unitVariant} ${pair.route} ${suffix}`)) {
+        for (let whenIndex = 0; whenIndex < whenSuffixes.length; whenIndex += 1) {
+            const whenSuffix = whenSuffixes[whenIndex];
+            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 + whenSuffix, base.lower + whenSuffix)) {
                         return suggestions;
                     }
                 }
             }
-            if (push(`${pair.route} ${suffix}`)) {
+            if (push(route + whenSuffix, routeLower + whenSuffix)) {
                 return suggestions;
             }
         }
-        for (const reason of prnReasons) {
-            for (const unitVariant of unitVariants) {
-                for (const dose of doseValues) {
-                    if (push(`${dose} ${unitVariant} ${pair.route} prn ${reason}`)) {
+        for (let reasonIndex = 0; reasonIndex < prnSuffixes.length; reasonIndex += 1) {
+            const reasonSuffix = prnSuffixes[reasonIndex];
+            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 + reasonSuffix, base.lower + reasonSuffix)) {
                         return suggestions;
                     }
                 }
             }
-            if (push(`${pair.route} prn ${reason}`)) {
+            if (push(route + reasonSuffix, routeLower + reasonSuffix)) {
                 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;
@@ -540,17 +685,34 @@ function suggestSig(input, options) {
     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 = PRECOMPUTED_WHEN_SEQUENCES;
-    const matcher = (candidate) => matchesPrefix(candidate, prefix, prefixCompact, prefixTokens, prefixTokensNoDashes, prefixCanonical, prefixCanonicalCompact, prefixNoDashes, prefixCanonicalNoDashes);
+    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.5",
+  "version": "0.1.7",
   "description": "Parse concise medication sigs into FHIR R5 Dosage JSON",
   "type": "module",
   "main": "dist/index.js",