ezmedicationinput 0.1.42 → 0.1.44

package/dist/site-phrases.js

@@ -0,0 +1,344 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTimingOnlySitePhrase = isTimingOnlySitePhrase;
+exports.hasExternalSurfaceModifier = hasExternalSurfaceModifier;
+exports.extractExplicitSiteCandidate = extractExplicitSiteCandidate;
+exports.selectBestResidualSiteCandidate = selectBestResidualSiteCandidate;
+exports.inferRouteHintFromSitePhrase = inferRouteHintFromSitePhrase;
+const maps_1 = require("./maps");
+const meaning_1 = require("./lexer/meaning");
+const types_1 = require("./types");
+function getInferableDefaultRouteHint(canonical, definition) {
+    const routeHint = definition === null || definition === void 0 ? void 0 : definition.routeHint;
+    if (!routeHint) {
+        return undefined;
+    }
+    switch (routeHint) {
+        case types_1.RouteCode["Ophthalmic route"]:
+            return canonical.includes("eye") || canonical.includes("eyelid")
+                ? routeHint
+                : undefined;
+        case types_1.RouteCode["Otic route"]:
+            return canonical.includes("ear") ? routeHint : undefined;
+        case types_1.RouteCode["Nasal route"]:
+            return canonical.includes("nostril") ||
+                canonical.includes("naris") ||
+                canonical.includes("nares") ||
+                canonical === "nose"
+                ? routeHint
+                : undefined;
+        case types_1.RouteCode["Oral route"]:
+            return canonical === "mouth" ? routeHint : undefined;
+        case types_1.RouteCode["Sublingual route"]:
+            return canonical.includes("tongue") ? routeHint : undefined;
+        case types_1.RouteCode["Buccal route"]:
+            return canonical.includes("cheek") ? routeHint : undefined;
+        case types_1.RouteCode["Intravenous route"]:
+            return canonical.includes("vein") ? routeHint : undefined;
+        case types_1.RouteCode["Per vagina"]:
+            return canonical.includes("vagina") ? routeHint : undefined;
+        case types_1.RouteCode["Per rectum"]:
+            return canonical.includes("rectum") || canonical === "anus"
+                ? routeHint
+                : undefined;
+        case types_1.RouteCode["Topical route"]:
+            return canonical.startsWith("affected ") ? routeHint : undefined;
+        default:
+            return undefined;
+    }
+}
+function mergeBodySiteRouteHint(canonical, customDefinition, defaultDefinition) {
+    var _a;
+    const definition = customDefinition !== null && customDefinition !== void 0 ? customDefinition : defaultDefinition;
+    if (!definition) {
+        return undefined;
+    }
+    const routeHint = (_a = customDefinition === null || customDefinition === void 0 ? void 0 : customDefinition.routeHint) !== null && _a !== void 0 ? _a : getInferableDefaultRouteHint(canonical, defaultDefinition);
+    if (routeHint === definition.routeHint) {
+        return definition;
+    }
+    return Object.assign(Object.assign({}, definition), { routeHint });
+}
+function isExplicitSiteBoundaryToken(lower, options, services) {
+    if (!lower) {
+        return true;
+    }
+    if ((0, meaning_1.isWorkflowInstructionWord)(lower)) {
+        return true;
+    }
+    if (maps_1.EVENT_TIMING_TOKENS[lower] ||
+        maps_1.TIMING_ABBREVIATIONS[lower] ||
+        maps_1.WORD_FREQUENCIES[lower] ||
+        services.hasFrequencyLikeWord(lower) ||
+        (0, meaning_1.isCountKeywordWord)(lower) ||
+        services.mapFrequencyAdverb(lower) ||
+        services.mapIntervalUnit(lower) ||
+        maps_1.MEAL_KEYWORDS[lower]) {
+        return true;
+    }
+    if (services.hasRouteLikeWord(lower, options) || services.normalizeUnit(lower, options)) {
+        return true;
+    }
+    if ((0, meaning_1.isApplicationVerbWord)(lower)) {
+        return true;
+    }
+    if (lower === "prn" || lower === "as" || lower === "needed" || lower === "for") {
+        return true;
+    }
+    if (services.isNumericToken(lower) && !services.isOrdinalToken(lower)) {
+        return true;
+    }
+    return false;
+}
+function isTimingOnlySitePhrase(words) {
+    if (!words.length) {
+        return true;
+    }
+    let phrase = "";
+    let allTimingWords = true;
+    for (let index = 0; index < words.length; index += 1) {
+        const word = words[index];
+        if (index > 0) {
+            phrase += " ";
+        }
+        phrase += word;
+        if (!maps_1.EVENT_TIMING_TOKENS[word] &&
+            !maps_1.TIMING_ABBREVIATIONS[word] &&
+            !maps_1.MEAL_KEYWORDS[word]) {
+            allTimingWords = false;
+        }
+    }
+    if (maps_1.EVENT_TIMING_TOKENS[phrase] ||
+        maps_1.TIMING_ABBREVIATIONS[phrase] ||
+        maps_1.MEAL_KEYWORDS[phrase]) {
+        return true;
+    }
+    return allTimingWords;
+}
+function hasExternalSurfaceModifier(siteText) {
+    const normalized = (0, maps_1.normalizeBodySiteKey)(siteText);
+    if (!normalized) {
+        return false;
+    }
+    const words = normalized.split(/\s+/);
+    for (const word of words) {
+        if (word.length > 0 && (0, meaning_1.isSiteSurfaceModifierWord)(word)) {
+            return true;
+        }
+    }
+    return false;
+}
+function extractExplicitSiteCandidate(tokens, consumed, startIndex, options, services) {
+    var _a;
+    const anchor = tokens[startIndex];
+    if (!anchor || consumed.has(anchor.index)) {
+        return undefined;
+    }
+    const anchorLower = services.normalizeTokenLower(anchor);
+    if (!(0, meaning_1.isSiteAnchorWord)(anchorLower)) {
+        return undefined;
+    }
+    if (!services.hasExplicitSiteIntroduction(startIndex)) {
+        return undefined;
+    }
+    const collected = [anchor.index];
+    const contentWords = [];
+    const candidateTextParts = [anchor.original];
+    let hasSiteHint = false;
+    for (let cursor = startIndex + 1; cursor < tokens.length; cursor += 1) {
+        const candidate = tokens[cursor];
+        if (!candidate || consumed.has(candidate.index)) {
+            break;
+        }
+        const lower = services.normalizeTokenLower(candidate);
+        if (/^[;:(),]+$/.test(lower)) {
+            break;
+        }
+        if (services.siteFillerWords.has(lower) && contentWords.length === 0) {
+            collected.push(candidate.index);
+            candidateTextParts.push(candidate.original);
+            continue;
+        }
+        if ((0, meaning_1.isSiteListConnectorWord)(lower) || lower === ",") {
+            let hasFollowingContent = false;
+            for (let lookahead = cursor + 1; lookahead < tokens.length; lookahead += 1) {
+                const lookaheadToken = tokens[lookahead];
+                if (!lookaheadToken || consumed.has(lookaheadToken.index)) {
+                    break;
+                }
+                const lookaheadLower = services.normalizeTokenLower(lookaheadToken);
+                if (services.siteFillerWords.has(lookaheadLower)) {
+                    continue;
+                }
+                hasFollowingContent = !isExplicitSiteBoundaryToken(lookaheadLower, options, services);
+                break;
+            }
+            if (!hasFollowingContent) {
+                break;
+            }
+            collected.push(candidate.index);
+            candidateTextParts.push(candidate.original);
+            continue;
+        }
+        if (isExplicitSiteBoundaryToken(lower, options, services)) {
+            if (lower === "top") {
+                const nextToken = services.getNextActiveToken(cursor);
+                if (nextToken && services.normalizeTokenLower(nextToken) === "of") {
+                    collected.push(candidate.index);
+                    candidateTextParts.push(candidate.original);
+                    contentWords.push(lower);
+                    hasSiteHint = true;
+                    continue;
+                }
+            }
+            break;
+        }
+        collected.push(candidate.index);
+        candidateTextParts.push(candidate.original);
+        if (!services.siteConnectors.has(lower) && !services.siteFillerWords.has(lower)) {
+            contentWords.push(lower);
+            if (services.isBodySiteHint(lower, services.customSiteHints) ||
+                (0, meaning_1.isSiteSurfaceModifierWord)(lower) ||
+                services.isOrdinalToken(lower)) {
+                hasSiteHint = true;
+            }
+        }
+    }
+    if (!contentWords.length || isTimingOnlySitePhrase(contentWords)) {
+        return undefined;
+    }
+    const candidateText = candidateTextParts.join(" ").replace(/\s+/g, " ").trim();
+    if (candidateText && ((_a = services.isInstructionLikeText) === null || _a === void 0 ? void 0 : _a.call(services, candidateText))) {
+        return undefined;
+    }
+    if (!hasSiteHint &&
+        contentWords.length === 1 &&
+        contentWords[0] !== "area" &&
+        anchorLower === "in") {
+        return undefined;
+    }
+    return {
+        tokenIndices: collected,
+        source: "explicit"
+    };
+}
+function selectBestResidualSiteCandidate(groups, prnSiteSuffixIndices, services) {
+    var _a;
+    let bestTokenIndices;
+    let bestScore = Number.NEGATIVE_INFINITY;
+    for (const group of groups) {
+        const filteredTokens = [];
+        const contentWords = [];
+        const candidateTextParts = [];
+        let hasWorkflowWord = false;
+        let knownWordCount = 0;
+        let modifierCount = 0;
+        for (const token of group.tokens) {
+            if (prnSiteSuffixIndices.has(token.index)) {
+                continue;
+            }
+            filteredTokens.push(token);
+            const lower = services.normalizeTokenLower(token);
+            if (lower.length === 0 ||
+                services.siteConnectors.has(lower) ||
+                services.siteFillerWords.has(lower) ||
+                (0, meaning_1.isSiteListConnectorWord)(lower) ||
+                lower === ",") {
+                continue;
+            }
+            candidateTextParts.push(token.original);
+            contentWords.push(lower);
+            if ((0, meaning_1.isWorkflowInstructionWord)(lower)) {
+                hasWorkflowWord = true;
+            }
+            if (services.isBodySiteHint(lower, services.customSiteHints)) {
+                knownWordCount += 1;
+            }
+            if ((0, meaning_1.isSiteSurfaceModifierWord)(lower) || services.isOrdinalToken(lower)) {
+                modifierCount += 1;
+            }
+        }
+        if (!filteredTokens.length) {
+            continue;
+        }
+        if (!contentWords.length || isTimingOnlySitePhrase(contentWords)) {
+            continue;
+        }
+        if (candidateTextParts.length) {
+            const candidateText = candidateTextParts.join(" ").replace(/\s+/g, " ").trim();
+            if (candidateText && ((_a = services.isInstructionLikeText) === null || _a === void 0 ? void 0 : _a.call(services, candidateText))) {
+                continue;
+            }
+        }
+        if (hasWorkflowWord) {
+            continue;
+        }
+        const startsWithApplicationContext = services.hasApplicationVerbBefore(filteredTokens[0].index);
+        const previous = services.getPreviousActiveToken(filteredTokens[0].index);
+        const anchoredBySiteConnector = previous
+            ? (0, meaning_1.isSiteAnchorWord)(services.normalizeTokenLower(previous))
+            : false;
+        if (knownWordCount === 0 &&
+            modifierCount === 0 &&
+            !anchoredBySiteConnector) {
+            continue;
+        }
+        const score = knownWordCount * 5 +
+            modifierCount * 2 +
+            (startsWithApplicationContext ? 2 : 0) +
+            (anchoredBySiteConnector ? 2 : 0) -
+            filteredTokens.length * 0.2 +
+            filteredTokens[0].index * 0.001;
+        if (score > bestScore) {
+            bestScore = score;
+            bestTokenIndices = [];
+            for (const token of filteredTokens) {
+                bestTokenIndices.push(token.index);
+            }
+        }
+    }
+    if (!bestTokenIndices || !bestTokenIndices.length) {
+        return undefined;
+    }
+    return {
+        tokenIndices: bestTokenIndices,
+        source: "residual"
+    };
+}
+function inferRouteHintFromSitePhrase(siteText, options, services) {
+    const canonical = (0, maps_1.normalizeBodySiteKey)(siteText);
+    if (!canonical) {
+        return undefined;
+    }
+    const customExact = services.lookupBodySiteDefinition(options === null || options === void 0 ? void 0 : options.siteCodeMap, canonical);
+    const exact = mergeBodySiteRouteHint(canonical, customExact, maps_1.DEFAULT_BODY_SITE_SNOMED[canonical]);
+    if (exact === null || exact === void 0 ? void 0 : exact.routeHint) {
+        return exact.routeHint;
+    }
+    if (hasExternalSurfaceModifier(siteText)) {
+        return undefined;
+    }
+    const words = [];
+    for (const word of canonical.split(/\s+/)) {
+        if (word.length > 0) {
+            words.push(word);
+        }
+    }
+    for (let length = words.length; length >= 1; length -= 1) {
+        for (let start = 0; start + length <= words.length; start += 1) {
+            let candidate = "";
+            for (let offset = 0; offset < length; offset += 1) {
+                if (offset > 0) {
+                    candidate += " ";
+                }
+                candidate += words[start + offset];
+            }
+            const customDefinition = services.lookupBodySiteDefinition(options === null || options === void 0 ? void 0 : options.siteCodeMap, candidate);
+            const definition = mergeBodySiteRouteHint(candidate, customDefinition, maps_1.DEFAULT_BODY_SITE_SNOMED[candidate]);
+            if (definition === null || definition === void 0 ? void 0 : definition.routeHint) {
+                return definition.routeHint;
+            }
+        }
+    }
+    return undefined;
+}

package/dist/timing-summary.d.ts

@@ -0,0 +1,25 @@
+import { EventTiming, FhirDayOfWeek, FhirPeriodUnit } from "./types";
+export interface TimingSummaryOptions {
+    groupMealTimingsByRelation?: boolean;
+    includeTimesPerDaySummary?: boolean;
+}
+export type MealRelation = "before" | "after" | "with";
+export type MealName = "breakfast" | "lunch" | "dinner";
+export interface MealTimingGroup {
+    relation: MealRelation;
+    meals: MealName[];
+    codes: EventTiming[];
+}
+export interface TimingSummaryInput {
+    frequency?: number;
+    frequencyMax?: number;
+    period?: number;
+    periodMax?: number;
+    periodUnit?: FhirPeriodUnit;
+    timingCode?: string;
+    dayOfWeek?: FhirDayOfWeek[];
+    when?: EventTiming[];
+    timeOfDay?: string[];
+}
+export declare function getMealTimingGroup(when: EventTiming[], options?: TimingSummaryOptions): MealTimingGroup | undefined;
+export declare function inferDailyOccurrenceCount(input: TimingSummaryInput, options?: TimingSummaryOptions): number | undefined;

package/dist/timing-summary.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMealTimingGroup = getMealTimingGroup;
+exports.inferDailyOccurrenceCount = inferDailyOccurrenceCount;
+const types_1 = require("./types");
+const MEAL_TIMING_DETAILS = {
+    [types_1.EventTiming["Before Breakfast"]]: { relation: "before", meal: "breakfast" },
+    [types_1.EventTiming["Before Lunch"]]: { relation: "before", meal: "lunch" },
+    [types_1.EventTiming["Before Dinner"]]: { relation: "before", meal: "dinner" },
+    [types_1.EventTiming["After Breakfast"]]: { relation: "after", meal: "breakfast" },
+    [types_1.EventTiming["After Lunch"]]: { relation: "after", meal: "lunch" },
+    [types_1.EventTiming["After Dinner"]]: { relation: "after", meal: "dinner" },
+    [types_1.EventTiming.Breakfast]: { relation: "with", meal: "breakfast" },
+    [types_1.EventTiming.Lunch]: { relation: "with", meal: "lunch" },
+    [types_1.EventTiming.Dinner]: { relation: "with", meal: "dinner" }
+};
+const MEAL_ORDER = {
+    breakfast: 0,
+    lunch: 1,
+    dinner: 2
+};
+const INFERABLE_DAILY_EVENT_TIMINGS = new Set([
+    types_1.EventTiming["Before Sleep"],
+    types_1.EventTiming["Before Breakfast"],
+    types_1.EventTiming["Before Lunch"],
+    types_1.EventTiming["Before Dinner"],
+    types_1.EventTiming["After Breakfast"],
+    types_1.EventTiming["After Lunch"],
+    types_1.EventTiming["After Dinner"],
+    types_1.EventTiming.Breakfast,
+    types_1.EventTiming.Lunch,
+    types_1.EventTiming.Dinner,
+    types_1.EventTiming.Morning,
+    types_1.EventTiming["Early Morning"],
+    types_1.EventTiming["Late Morning"],
+    types_1.EventTiming.Noon,
+    types_1.EventTiming.Afternoon,
+    types_1.EventTiming["Early Afternoon"],
+    types_1.EventTiming["Late Afternoon"],
+    types_1.EventTiming.Evening,
+    types_1.EventTiming["Early Evening"],
+    types_1.EventTiming["Late Evening"],
+    types_1.EventTiming.Night,
+    types_1.EventTiming.Wake,
+    types_1.EventTiming["After Sleep"]
+]);
+function uniqueValues(values) {
+    const seen = new Set();
+    const result = [];
+    for (const value of values) {
+        if (!seen.has(value)) {
+            seen.add(value);
+            result.push(value);
+        }
+    }
+    return result;
+}
+function getMealTimingGroup(when, options) {
+    if (!(options === null || options === void 0 ? void 0 : options.groupMealTimingsByRelation)) {
+        return undefined;
+    }
+    const uniqueWhen = uniqueValues(when);
+    if (uniqueWhen.length < 2) {
+        return undefined;
+    }
+    let relation;
+    const meals = [];
+    const groupedCodes = [];
+    let sawFirstMeal = false;
+    for (let i = 0; i < uniqueWhen.length; i += 1) {
+        const code = uniqueWhen[i];
+        const detail = MEAL_TIMING_DETAILS[code];
+        if (!detail) {
+            if (sawFirstMeal) {
+                break;
+            }
+            continue;
+        }
+        if (!sawFirstMeal) {
+            sawFirstMeal = true;
+        }
+        if (!relation) {
+            relation = detail.relation;
+        }
+        else if (relation !== detail.relation) {
+            break;
+        }
+        meals.push(detail.meal);
+        groupedCodes.push(code);
+    }
+    if (groupedCodes.length < 2) {
+        return undefined;
+    }
+    for (let i = 1; i < meals.length; i += 1) {
+        const current = meals[i];
+        let j = i - 1;
+        while (j >= 0 && MEAL_ORDER[meals[j]] > MEAL_ORDER[current]) {
+            meals[j + 1] = meals[j];
+            j -= 1;
+        }
+        meals[j + 1] = current;
+    }
+    if (!relation) {
+        return undefined;
+    }
+    return {
+        relation,
+        meals,
+        codes: groupedCodes
+    };
+}
+function inferDailyOccurrenceCount(input, options) {
+    var _a, _b, _c, _d;
+    if (!(options === null || options === void 0 ? void 0 : options.includeTimesPerDaySummary)) {
+        return undefined;
+    }
+    if (input.frequency !== undefined || input.frequencyMax !== undefined || input.timingCode) {
+        return undefined;
+    }
+    if (input.period !== undefined || input.periodMax !== undefined || input.periodUnit !== undefined) {
+        return undefined;
+    }
+    if (((_b = (_a = input.dayOfWeek) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0) > 0) {
+        return undefined;
+    }
+    const uniqueWhen = uniqueValues((_c = input.when) !== null && _c !== void 0 ? _c : []);
+    for (let i = 0; i < uniqueWhen.length; i += 1) {
+        if (!INFERABLE_DAILY_EVENT_TIMINGS.has(uniqueWhen[i])) {
+            return undefined;
+        }
+    }
+    const uniqueTimes = uniqueValues((_d = input.timeOfDay) !== null && _d !== void 0 ? _d : []);
+    const occurrences = uniqueWhen.length + uniqueTimes.length;
+    if (occurrences === 0) {
+        return undefined;
+    }
+    return occurrences;
+}