ezmedicationinput 0.1.22 → 0.1.24

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { FhirDosage, FormatOptions, ParseOptions, ParseResult } from "./types";
+import { FhirDosage, FormatOptions, LintResult, ParseOptions, ParseResult } from "./types";
 export { parseInternal } from "./parser";
 export { suggestSig } from "./suggest";
 export * from "./types";
@@ -6,6 +6,7 @@ export { nextDueDoses } from "./schedule";
 export { getRegisteredSigLocalizations, registerSigLocalization, resolveSigLocalization, resolveSigTranslation } from "./i18n";
 export type { SigLocalization, SigLocalizationConfig, SigTranslation, SigTranslationConfig } from "./i18n";
 export declare function parseSig(input: string, options?: ParseOptions): ParseResult;
+export declare function lintSig(input: string, options?: ParseOptions): LintResult;
 export declare function parseSigAsync(input: string, options?: ParseOptions): Promise<ParseResult>;
 export declare function formatSig(dosage: FhirDosage, style?: "short" | "long", options?: FormatOptions): string;
 export declare function fromFhirDosage(dosage: FhirDosage, options?: FormatOptions): ParseResult;

package/dist/index.js

@@ -25,6 +25,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveSigTranslation = exports.resolveSigLocalization = exports.registerSigLocalization = exports.getRegisteredSigLocalizations = exports.nextDueDoses = exports.suggestSig = exports.parseInternal = void 0;
 exports.parseSig = parseSig;
+exports.lintSig = lintSig;
 exports.parseSigAsync = parseSigAsync;
 exports.formatSig = formatSig;
 exports.fromFhirDosage = fromFhirDosage;
@@ -50,6 +51,25 @@ function parseSig(input, options) {
     (0, parser_1.applySiteCoding)(internal, options);
     return buildParseResult(internal, options);
 }
+function lintSig(input, options) {
+    const internal = (0, parser_1.parseInternal)(input, options);
+    (0, parser_1.applyPrnReasonCoding)(internal, options);
+    (0, parser_1.applySiteCoding)(internal, options);
+    const result = buildParseResult(internal, options);
+    const groups = (0, parser_1.findUnparsedTokenGroups)(internal);
+    const issues = groups.map((group) => {
+        const text = group.range
+            ? internal.input.slice(group.range.start, group.range.end)
+            : group.tokens.map((token) => token.original).join(" ");
+        return {
+            message: "Unrecognized text",
+            text: text.trim() || text,
+            tokens: group.tokens.map((token) => token.original),
+            range: group.range
+        };
+    });
+    return { result, issues };
+}
 function parseSigAsync(input, options) {
     return __awaiter(this, void 0, void 0, function* () {
         const internal = (0, parser_1.parseInternal)(input, options);

package/dist/parser.d.ts

@@ -1,6 +1,10 @@
 import { ParsedSigInternal, Token } from "./internal-types";
-import { ParseOptions } from "./types";
+import { ParseOptions, TextRange } from "./types";
 export declare function tokenize(input: string): Token[];
+export declare function findUnparsedTokenGroups(internal: ParsedSigInternal): Array<{
+    tokens: Token[];
+    range?: TextRange;
+}>;
 export declare function parseInternal(input: string, options?: ParseOptions): ParsedSigInternal;
 /**
  * Resolves parsed site text against SNOMED dictionaries and synchronous

package/dist/parser.js

@@ -10,6 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.tokenize = tokenize;
+exports.findUnparsedTokenGroups = findUnparsedTokenGroups;
 exports.parseInternal = parseInternal;
 exports.applyPrnReasonCoding = applyPrnReasonCoding;
 exports.applyPrnReasonCodingAsync = applyPrnReasonCodingAsync;
@@ -885,6 +886,68 @@ function refineSiteRange(input, sanitized, tokenRange) {
     }
     return { start: startIndex, end: startIndex + lowerSanitized.length };
 }
+function findUnparsedTokenGroups(internal) {
+    const leftoverTokens = internal.tokens
+        .filter((token) => !internal.consumed.has(token.index))
+        .sort((a, b) => a.index - b.index);
+    if (leftoverTokens.length === 0) {
+        return [];
+    }
+    const groups = [];
+    let currentGroup = [];
+    let previousIndex;
+    let minimumStart = 0;
+    const locateRange = (tokensToLocate, initial) => {
+        const lowerInput = internal.input.toLowerCase();
+        let searchStart = minimumStart;
+        let rangeStart;
+        let rangeEnd;
+        for (const token of tokensToLocate) {
+            const segment = token.original.trim();
+            if (!segment) {
+                continue;
+            }
+            const lowerSegment = segment.toLowerCase();
+            const foundIndex = lowerInput.indexOf(lowerSegment, searchStart);
+            if (foundIndex === -1) {
+                return initial;
+            }
+            if (rangeStart === undefined) {
+                rangeStart = foundIndex;
+            }
+            const segmentEnd = foundIndex + lowerSegment.length;
+            rangeEnd = rangeEnd === undefined ? segmentEnd : Math.max(rangeEnd, segmentEnd);
+            searchStart = segmentEnd;
+        }
+        if (rangeStart === undefined || rangeEnd === undefined) {
+            return initial;
+        }
+        return { start: rangeStart, end: rangeEnd };
+    };
+    const flush = () => {
+        if (!currentGroup.length) {
+            return;
+        }
+        const indices = currentGroup.map((token) => token.index);
+        const initialRange = computeTokenRange(internal.input, internal.tokens, indices);
+        const range = locateRange(currentGroup, initialRange);
+        groups.push({ tokens: currentGroup, range });
+        if (range) {
+            minimumStart = Math.max(minimumStart, range.end);
+        }
+        currentGroup = [];
+        previousIndex = undefined;
+    };
+    for (const token of leftoverTokens) {
+        if (previousIndex !== undefined && token.index !== previousIndex + 1) {
+            flush();
+        }
+        currentGroup.push(token);
+        previousIndex = token.index;
+    }
+    flush();
+    return groups;
+}
 function splitToken(token) {
     if (/^[0-9]+(?:\.[0-9]+)?$/.test(token)) {
         return [token];
@@ -1513,13 +1576,14 @@ function parseInternal(input, options) {
         }
     }
     // Multiplicative tokens like 1x3
-    for (const token of tokens) {
+    for (let i = 0; i < tokens.length; i++) {
+        const token = tokens[i];
         if (internal.consumed.has(token.index))
             continue;
-        const match = token.lower.match(/^([0-9]+(?:\.[0-9]+)?)[x*]([0-9]+(?:\.[0-9]+)?)$/);
-        if (match) {
-            const dose = parseFloat(match[1]);
-            const freq = parseFloat(match[2]);
+        const combined = token.lower.match(/^([0-9]+(?:\.[0-9]+)?)[x*]([0-9]+(?:\.[0-9]+)?)$/);
+        if (combined) {
+            const dose = parseFloat(combined[1]);
+            const freq = parseFloat(combined[2]);
             if (internal.dose === undefined) {
                 internal.dose = dose;
             }
@@ -1527,6 +1591,55 @@ function parseInternal(input, options) {
             internal.period = 1;
             internal.periodUnit = types_1.FhirPeriodUnit.Day;
             mark(internal.consumed, token);
+            continue;
+        }
+        const hasNumericDoseBefore = () => {
+            for (let j = i - 1; j >= 0; j--) {
+                const prev = tokens[j];
+                if (!prev) {
+                    continue;
+                }
+                if (internal.consumed.has(prev.index)) {
+                    continue;
+                }
+                if (/^[0-9]+(?:\.[0-9]+)?$/.test(prev.lower)) {
+                    return true;
+                }
+                if (normalizeUnit(prev.lower, options)) {
+                    continue;
+                }
+                break;
+            }
+            return false;
+        };
+        if (internal.frequency === undefined && hasNumericDoseBefore()) {
+            const prefix = token.lower.match(/^[x*]([0-9]+(?:\.[0-9]+)?)$/);
+            if (prefix) {
+                const freq = parseFloat(prefix[1]);
+                if (Number.isFinite(freq)) {
+                    internal.frequency = freq;
+                    internal.period = 1;
+                    internal.periodUnit = types_1.FhirPeriodUnit.Day;
+                    mark(internal.consumed, token);
+                    continue;
+                }
+            }
+            if (token.lower === "x" || token.lower === "*") {
+                const next = tokens[i + 1];
+                if (next &&
+                    !internal.consumed.has(next.index) &&
+                    /^[0-9]+(?:\.[0-9]+)?$/.test(next.lower)) {
+                    const freq = parseFloat(next.original);
+                    if (Number.isFinite(freq)) {
+                        internal.frequency = freq;
+                        internal.period = 1;
+                        internal.periodUnit = types_1.FhirPeriodUnit.Day;
+                        mark(internal.consumed, token);
+                        mark(internal.consumed, next);
+                        continue;
+                    }
+                }
+            }
         }
     }
     const applyRouteDescriptor = (code, text) => {

package/dist/types.d.ts

@@ -527,6 +527,22 @@ export interface ParseResult {
         }>;
     };
 }
+export interface LintIssue {
+    /** Human-readable description of why the segment could not be parsed. */
+    message: string;
+    /** Original substring that triggered the issue. */
+    text: string;
+    /** Tokens contributing to the unparsed segment. */
+    tokens: string[];
+    /** Location of {@link text} relative to the caller's original input. */
+    range?: TextRange;
+}
+export interface LintResult {
+    /** Standard parse output including FHIR representation and metadata. */
+    result: ParseResult;
+    /** Segments of the input that could not be interpreted. */
+    issues: LintIssue[];
+}
 /**
  * Maps EventTiming codes (or other institution-specific timing strings) to
  * 24-hour clock representations such as "08:00".

package/package.json

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