ezmedicationinput 0.1.0 → 0.1.1

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 import { FhirDosage, ParseOptions, ParseResult } from "./types";
 export { parseInternal } from "./parser";
+export { suggestSig } from "./suggest";
 export * from "./types";
 export { nextDueDoses } from "./schedule";
 export declare function parseSig(input: string, options?: ParseOptions): ParseResult;

package/dist/index.js

@@ -2,6 +2,7 @@ import { formatInternal } from "./format";
 import { internalFromFhir, toFhir } from "./fhir";
 import { parseInternal } from "./parser";
 export { parseInternal } from "./parser";
+export { suggestSig } from "./suggest";
 export * from "./types";
 export { nextDueDoses } from "./schedule";
 export function parseSig(input, options) {

package/dist/maps.js

@@ -53,63 +53,83 @@ export const DEFAULT_ROUTE_SYNONYMS = (() => {
         }
         map[normalized] = { code, text: ROUTE_TEXT[code] };
     };
-    assign("po", RouteCode["Oral route"]);
-    assign("oral", RouteCode["Oral route"]);
-    assign("by mouth", RouteCode["Oral route"]);
-    assign("per os", RouteCode["Oral route"]);
-    assign("sl", RouteCode["Sublingual route"]);
-    assign("s.l.", RouteCode["Sublingual route"]);
-    assign("sublingual", RouteCode["Sublingual route"]);
-    assign("buccal", RouteCode["Buccal route"]);
-    assign("inh", RouteCode["Respiratory tract route (qualifier value)"]);
-    assign("inhalation", RouteCode["Respiratory tract route (qualifier value)"]);
-    assign("inhaled", RouteCode["Respiratory tract route (qualifier value)"]);
-    assign("iv", RouteCode["Intravenous route"]);
-    assign("ivp", RouteCode["Intravenous route"]);
-    assign("ivpb", RouteCode["Intravenous route"]);
-    assign("iv push", RouteCode["Intravenous route"]);
-    assign("iv bolus", RouteCode["Intravenous route"]);
-    assign("iv drip", RouteCode["Intravenous route"]);
-    assign("intravenous", RouteCode["Intravenous route"]);
-    assign("im", RouteCode["Intramuscular route"]);
-    assign("im injection", RouteCode["Intramuscular route"]);
-    assign("intramuscular", RouteCode["Intramuscular route"]);
-    assign("sc", RouteCode["Subcutaneous route"]);
-    assign("sq", RouteCode["Subcutaneous route"]);
-    assign("subq", RouteCode["Subcutaneous route"]);
-    assign("subcut", RouteCode["Subcutaneous route"]);
-    assign("subcutaneous", RouteCode["Subcutaneous route"]);
-    assign("in", RouteCode["Nasal route"]);
-    assign("intranasal", RouteCode["Nasal route"]);
-    assign("nasal", RouteCode["Nasal route"]);
-    assign("top", RouteCode["Topical route"]);
-    assign("topical", RouteCode["Topical route"]);
-    assign("td", RouteCode["Transdermal route"]);
-    assign("patch", RouteCode["Transdermal route"]);
-    assign("transdermal", RouteCode["Transdermal route"]);
-    assign("pr", RouteCode["Per rectum"]);
-    assign("rectal", RouteCode["Per rectum"]);
-    assign("pv", RouteCode["Per vagina"]);
-    assign("vaginal", RouteCode["Per vagina"]);
-    assign("oph", RouteCode["Ophthalmic route"]);
-    assign("ophth", RouteCode["Ophthalmic route"]);
-    assign("ophthalmic", RouteCode["Ophthalmic route"]);
-    assign("ocular", RouteCode["Ophthalmic route"]);
-    assign("intravitreal", RouteCode["Intravitreal route (qualifier value)"]);
-    assign("intravitreal injection", RouteCode["Intravitreal route (qualifier value)"]);
-    assign("ivt", RouteCode["Intravitreal route (qualifier value)"]);
+    const registerVariants = (value, code) => {
+        if (!value)
+            return;
+        assign(value, code);
+        const withoutParens = value
+            .replace(/[()]/g, " ")
+            .replace(/\s+/g, " ")
+            .trim();
+        assign(withoutParens, code);
+        const withoutCommas = value
+            .replace(/,/g, " ")
+            .replace(/\s+/g, " ")
+            .trim();
+        assign(withoutCommas, code);
+        const withoutPunctuation = value
+            .replace(/[().,-]/g, " ")
+            .replace(/\s+/g, " ")
+            .trim();
+        assign(withoutPunctuation, code);
+    };
+    registerVariants("po", RouteCode["Oral route"]);
+    registerVariants("oral", RouteCode["Oral route"]);
+    registerVariants("by mouth", RouteCode["Oral route"]);
+    registerVariants("per os", RouteCode["Oral route"]);
+    registerVariants("sl", RouteCode["Sublingual route"]);
+    registerVariants("s.l.", RouteCode["Sublingual route"]);
+    registerVariants("sublingual", RouteCode["Sublingual route"]);
+    registerVariants("buccal", RouteCode["Buccal route"]);
+    registerVariants("inh", RouteCode["Respiratory tract route (qualifier value)"]);
+    registerVariants("inhalation", RouteCode["Respiratory tract route (qualifier value)"]);
+    registerVariants("inhaled", RouteCode["Respiratory tract route (qualifier value)"]);
+    registerVariants("iv", RouteCode["Intravenous route"]);
+    registerVariants("ivp", RouteCode["Intravenous route"]);
+    registerVariants("ivpb", RouteCode["Intravenous route"]);
+    registerVariants("iv push", RouteCode["Intravenous route"]);
+    registerVariants("iv bolus", RouteCode["Intravenous route"]);
+    registerVariants("iv drip", RouteCode["Intravenous route"]);
+    registerVariants("intravenous", RouteCode["Intravenous route"]);
+    registerVariants("im", RouteCode["Intramuscular route"]);
+    registerVariants("im injection", RouteCode["Intramuscular route"]);
+    registerVariants("intramuscular", RouteCode["Intramuscular route"]);
+    registerVariants("sc", RouteCode["Subcutaneous route"]);
+    registerVariants("sq", RouteCode["Subcutaneous route"]);
+    registerVariants("subq", RouteCode["Subcutaneous route"]);
+    registerVariants("subcut", RouteCode["Subcutaneous route"]);
+    registerVariants("subcutaneous", RouteCode["Subcutaneous route"]);
+    registerVariants("in", RouteCode["Nasal route"]);
+    registerVariants("intranasal", RouteCode["Nasal route"]);
+    registerVariants("nasal", RouteCode["Nasal route"]);
+    registerVariants("top", RouteCode["Topical route"]);
+    registerVariants("topical", RouteCode["Topical route"]);
+    registerVariants("td", RouteCode["Transdermal route"]);
+    registerVariants("patch", RouteCode["Transdermal route"]);
+    registerVariants("transdermal", RouteCode["Transdermal route"]);
+    registerVariants("pr", RouteCode["Per rectum"]);
+    registerVariants("rectal", RouteCode["Per rectum"]);
+    registerVariants("pv", RouteCode["Per vagina"]);
+    registerVariants("vaginal", RouteCode["Per vagina"]);
+    registerVariants("oph", RouteCode["Ophthalmic route"]);
+    registerVariants("ophth", RouteCode["Ophthalmic route"]);
+    registerVariants("ophthalmic", RouteCode["Ophthalmic route"]);
+    registerVariants("ocular", RouteCode["Ophthalmic route"]);
+    registerVariants("intravitreal", RouteCode["Intravitreal route (qualifier value)"]);
+    registerVariants("intravitreal injection", RouteCode["Intravitreal route (qualifier value)"]);
+    registerVariants("ivt", RouteCode["Intravitreal route (qualifier value)"]);
     for (const [routeCode, meta] of ROUTE_SNOMED_ENTRIES) {
         const display = meta.display.toLowerCase();
-        assign(display, routeCode);
+        registerVariants(display, routeCode);
         const withoutQualifier = display.replace(/\s*\(qualifier value\)/g, "").trim();
-        assign(withoutQualifier, routeCode);
+        registerVariants(withoutQualifier, routeCode);
         const withoutSuffix = withoutQualifier
             .replace(/\b(route|use)\b/g, "")
             .replace(/\s+/g, " ")
             .trim();
-        assign(withoutSuffix, routeCode);
+        registerVariants(withoutSuffix, routeCode);
         const withoutPer = withoutSuffix.replace(/^per\s+/, "").trim();
-        assign(withoutPer, routeCode);
+        registerVariants(withoutPer, routeCode);
     }
     return map;
 })();

package/dist/parser.js

@@ -609,7 +609,7 @@ export function parseInternal(input, options) {
     }
     // Process tokens sequentially
     const tryRouteSynonym = (startIndex) => {
-        const maxSpan = Math.min(5, tokens.length - startIndex);
+        const maxSpan = Math.min(24, tokens.length - startIndex);
         for (let span = maxSpan; span >= 1; span--) {
             const slice = tokens.slice(startIndex, startIndex + span);
             if (slice.some((part) => internal.consumed.has(part.index))) {

package/dist/suggest.d.ts

@@ -0,0 +1,12 @@
+import { ParseOptions } from "./types";
+export interface SuggestSigOptions extends ParseOptions {
+    /**
+     * Maximum number of suggestions to return. Defaults to 10 when not supplied.
+     */
+    limit?: number;
+    /**
+     * Optional custom PRN reasons to use when generating suggestions.
+     */
+    prnReasons?: readonly string[];
+}
+export declare function suggestSig(input: string, options?: SuggestSigOptions): string[];

package/dist/suggest.js

@@ -0,0 +1,223 @@
+import { inferUnitFromContext } from "./context";
+const DEFAULT_LIMIT = 10;
+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" }
+];
+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 DEFAULT_PRN_REASONS = [
+    "pain",
+    "nausea",
+    "itching",
+    "anxiety",
+    "sleep",
+    "cough",
+    "fever",
+    "spasm",
+    "constipation",
+    "dyspnea",
+];
+const DEFAULT_DOSE_COUNTS = ["1", "2"];
+function normalizeKey(value) {
+    return value.trim().toLowerCase();
+}
+function normalizeSpacing(value) {
+    return value
+        .trim()
+        .replace(/\s+/g, " ");
+}
+function buildUnitRoutePairs(contextUnit) {
+    const pairs = [];
+    const seen = new Set();
+    const addPair = (unit, route) => {
+        if (!unit) {
+            return;
+        }
+        const cleanUnit = unit.trim();
+        if (!cleanUnit) {
+            return;
+        }
+        const normalizedUnit = cleanUnit.toLowerCase();
+        const resolvedRoute = route ?? DEFAULT_ROUTE_BY_UNIT[normalizedUnit] ?? "po";
+        const key = `${normalizedUnit}::${resolvedRoute.toLowerCase()}`;
+        if (seen.has(key)) {
+            return;
+        }
+        seen.add(key);
+        pairs.push({ unit: cleanUnit, route: resolvedRoute });
+    };
+    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);
+    }
+    return pairs;
+}
+function buildPrnReasons(customReasons) {
+    const reasons = new Set();
+    const add = (reason) => {
+        if (!reason) {
+            return;
+        }
+        const normalized = normalizeSpacing(reason.toLowerCase());
+        if (!normalized) {
+            return;
+        }
+        reasons.add(normalized);
+    };
+    if (customReasons) {
+        for (const reason of customReasons) {
+            add(reason);
+        }
+    }
+    for (const reason of DEFAULT_PRN_REASONS) {
+        add(reason);
+    }
+    return [...reasons];
+}
+function extractDoseValuesFromInput(input) {
+    const matches = input.match(/\d+(?:\.\d+)?(?:\/\d+(?:\.\d+)?)?/g);
+    if (!matches) {
+        return [];
+    }
+    const values = new Set();
+    for (const match of matches) {
+        if (!match) {
+            continue;
+        }
+        values.add(match);
+    }
+    return [...values];
+}
+function buildDoseValues(input) {
+    const dynamicValues = extractDoseValuesFromInput(input);
+    const values = new Set();
+    for (const value of dynamicValues) {
+        values.add(value);
+    }
+    for (const value of DEFAULT_DOSE_COUNTS) {
+        values.add(value);
+    }
+    return [...values];
+}
+function generateCandidateSignatures(pairs, doseValues, prnReasons) {
+    const suggestions = [];
+    const seen = new Set();
+    const push = (value) => {
+        const normalized = normalizeSpacing(value);
+        if (!normalized) {
+            return;
+        }
+        const key = normalizeKey(normalized);
+        if (seen.has(key)) {
+            return;
+        }
+        seen.add(key);
+        suggestions.push(normalized);
+    };
+    for (const pair of pairs) {
+        for (const code of FREQUENCY_CODES) {
+            for (const dose of doseValues) {
+                push(`${dose} ${pair.unit} ${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}`);
+                }
+            }
+            push(`${pair.route} ${interval}`);
+        }
+        for (const freq of FREQUENCY_NUMBERS) {
+            const freqToken = FREQ_TOKEN_BY_NUMBER[freq];
+            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}`);
+            }
+            push(`${pair.route} ${when}`);
+        }
+        for (const reason of prnReasons) {
+            push(`1 ${pair.unit} ${pair.route} prn ${reason}`);
+        }
+    }
+    return suggestions;
+}
+function matchesPrefix(candidate, prefix, prefixCompact) {
+    if (!prefix) {
+        return true;
+    }
+    const normalizedCandidate = candidate.toLowerCase();
+    if (normalizedCandidate.startsWith(prefix)) {
+        return true;
+    }
+    const compactCandidate = normalizedCandidate.replace(/\s+/g, "");
+    return compactCandidate.startsWith(prefixCompact);
+}
+export function suggestSig(input, options) {
+    const limit = options?.limit ?? DEFAULT_LIMIT;
+    const prefix = normalizeSpacing(input.toLowerCase());
+    const prefixCompact = prefix.replace(/\s+/g, "");
+    const contextUnit = inferUnitFromContext(options?.context ?? undefined);
+    const pairs = buildUnitRoutePairs(contextUnit);
+    const doseValues = buildDoseValues(input);
+    const prnReasons = buildPrnReasons(options?.prnReasons);
+    const candidates = generateCandidateSignatures(pairs, doseValues, prnReasons);
+    const results = [];
+    for (const candidate of candidates) {
+        if (matchesPrefix(candidate, prefix, prefixCompact)) {
+            results.push(candidate);
+        }
+        if (results.length >= limit) {
+            break;
+        }
+    }
+    return results;
+}

package/dist/types.d.ts

@@ -167,6 +167,7 @@ export declare enum SNOMEDCTRouteCodes {
     "Intrapulmonary route (qualifier value)" = "420201002",
     "Mucous fistula route (qualifier value)" = "420204005",
     "Nasoduodenal route (qualifier value)" = "420218003",
+    "Body cavity route" = "420254004",
     "A route that begins within a non-pathologic hollow cavity, such as that of the abdominal cavity or uterus." = "420254004",
     "Intraventricular route - cardiac (qualifier value)" = "420287000",
     "Intracerebroventricular route (qualifier value)" = "420719007",

package/dist/types.js

@@ -148,6 +148,7 @@ export var SNOMEDCTRouteCodes;
     SNOMEDCTRouteCodes["Intrapulmonary route (qualifier value)"] = "420201002";
     SNOMEDCTRouteCodes["Mucous fistula route (qualifier value)"] = "420204005";
     SNOMEDCTRouteCodes["Nasoduodenal route (qualifier value)"] = "420218003";
+    SNOMEDCTRouteCodes["Body cavity route"] = "420254004";
     SNOMEDCTRouteCodes["A route that begins within a non-pathologic hollow cavity, such as that of the abdominal cavity or uterus."] = "420254004";
     SNOMEDCTRouteCodes["Intraventricular route - cardiac (qualifier value)"] = "420287000";
     SNOMEDCTRouteCodes["Intracerebroventricular route (qualifier value)"] = "420719007";

package/package.json

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