ezmedicationinput 0.1.43 → 0.1.45

package/dist/ir.d.ts

@@ -0,0 +1,4 @@
+import { ParserState } from "./parser-state";
+import { CanonicalSigClause } from "./types";
+export declare function buildCanonicalSigClauses(internal: ParserState): CanonicalSigClause[];
+export declare function shiftCanonicalSigClauses(clauses: CanonicalSigClause[], offset: number): void;

package/dist/lexer/lex.d.ts

@@ -0,0 +1,2 @@
+import { LexToken } from "./token-types";
+export declare function lexInput(input: string): LexToken[];

package/dist/lexer/meaning.d.ts

@@ -0,0 +1,71 @@
+import { FrequencyDescriptor, RouteSynonym } from "../maps";
+import { EventTiming, FhirDayOfWeek, RouteCode } from "../types";
+import { LexToken } from "./token-types";
+export declare enum ConnectorRole {
+    General = "GENERAL",
+    SiteAnchor = "SITE_ANCHOR",
+    SiteList = "SITE_LIST",
+    MealContext = "MEAL_CONTEXT",
+    DayRange = "DAY_RANGE"
+}
+export declare enum TokenWordClass {
+    AdministrationVerb = "ADMINISTRATION_VERB",
+    SiteSurfaceModifier = "SITE_SURFACE_MODIFIER",
+    WorkflowInstruction = "WORKFLOW_INSTRUCTION",
+    ApplicationVerb = "APPLICATION_VERB",
+    CountKeyword = "COUNT_KEYWORD"
+}
+export interface SiteMeaningCandidate {
+    text: string;
+    route?: RouteCode;
+    source: string;
+}
+export interface RouteMeaningCandidate extends RouteSynonym {
+    source: string;
+}
+export interface TokenAnnotations {
+    eventTiming?: EventTiming;
+    timingAbbreviation?: FrequencyDescriptor;
+    dayOfWeek?: FhirDayOfWeek[];
+    routeCandidates?: RouteMeaningCandidate[];
+    siteCandidates?: SiteMeaningCandidate[];
+    prn?: true;
+    connectorRoles?: ConnectorRole[];
+    wordClasses?: TokenWordClass[];
+}
+export interface AnnotatedLexToken extends LexToken {
+    annotations?: TokenAnnotations;
+}
+interface Lowerable {
+    lower: string;
+    annotations?: TokenAnnotations;
+}
+export declare function expandDayMeaningRange(start: FhirDayOfWeek, end: FhirDayOfWeek): FhirDayOfWeek[];
+export declare function resolveDayMeaning(tokenLower: string): FhirDayOfWeek[] | undefined;
+export declare function annotateLexToken(token: LexToken): AnnotatedLexToken;
+export declare function annotateLexTokens(tokens: LexToken[]): AnnotatedLexToken[];
+export declare function hasConnectorRole(token: AnnotatedLexToken | undefined, role: ConnectorRole): boolean;
+export declare function hasTokenWordClass(token: AnnotatedLexToken | undefined, wordClass: TokenWordClass): boolean;
+export declare function hasDayOfWeekMeaning(token: Lowerable | undefined): boolean;
+export declare function getDayOfWeekMeaning(token: Lowerable | undefined): FhirDayOfWeek[] | undefined;
+export declare function hasEventTimingMeaning(token: Lowerable | undefined): boolean;
+export declare function getEventTimingMeaning(token: Lowerable | undefined): EventTiming | undefined;
+export declare function hasTimingAbbreviationMeaning(token: Lowerable | undefined): boolean;
+export declare function getTimingAbbreviationMeaning(token: Lowerable | undefined): FrequencyDescriptor | undefined;
+export declare function hasRouteMeaning(token: Lowerable | undefined): boolean;
+export declare function getRouteMeaning(token: Lowerable | undefined): RouteMeaningCandidate | undefined;
+export declare function hasSiteMeaningCandidate(token: Lowerable | undefined): boolean;
+export declare function getSiteMeaningCandidates(token: Lowerable | undefined): SiteMeaningCandidate[] | undefined;
+export declare function getPrimarySiteMeaningCandidate(token: Lowerable | undefined): SiteMeaningCandidate | undefined;
+export declare function hasPrnMeaning(token: Lowerable | undefined): boolean;
+export declare function hasConnectorMeaning(token: Lowerable | undefined): boolean;
+export declare function isSiteAnchorWord(word: string): boolean;
+export declare function isSiteListConnectorWord(word: string): boolean;
+export declare function isSiteSurfaceModifierWord(word: string): boolean;
+export declare function isWorkflowInstructionWord(word: string): boolean;
+export declare function isApplicationVerbWord(word: string): boolean;
+export declare function isAdministrationVerbWord(word: string): boolean;
+export declare function isCountKeywordWord(word: string): boolean;
+export declare function isMealContextConnectorWord(word: string): boolean;
+export declare function isDayRangeConnectorWord(word: string): boolean;
+export {};

package/dist/lexer/surface.d.ts

@@ -0,0 +1,2 @@
+import { SurfaceToken } from "./token-types";
+export declare function scanSurfaceTokens(input: string): SurfaceToken[];

package/dist/lexer/token-types.d.ts

@@ -0,0 +1,36 @@
+export declare enum SurfaceTokenKind {
+    Text = "TEXT",
+    Separator = "SEPARATOR",
+    Punctuation = "PUNCTUATION"
+}
+export declare enum LexKind {
+    Word = "WORD",
+    Number = "NUMBER",
+    NumberRange = "NUMBER_RANGE",
+    Ordinal = "ORDINAL",
+    TimeLike = "TIME_LIKE",
+    Separator = "SEPARATOR",
+    Punctuation = "PUNCTUATION"
+}
+export interface SurfaceToken {
+    original: string;
+    lower: string;
+    index: number;
+    kind: SurfaceTokenKind;
+    start: number;
+    end: number;
+}
+export interface LexToken {
+    original: string;
+    lower: string;
+    index: number;
+    kind: LexKind;
+    value?: number;
+    low?: number;
+    high?: number;
+    sourceStart: number;
+    sourceEnd: number;
+    surfaceIndices: number[];
+    sourceText?: string;
+    derived?: true;
+}

package/dist/maps.d.ts

@@ -1,4 +1,4 @@
-import { AdditionalInstructionDefinition, BodySiteDefinition, EventTiming, FhirDayOfWeek, FhirPeriodUnit, PrnReasonDefinition, RouteCode, SNOMEDCTRouteCodes } from "./types";
+import { BodySiteDefinition, EventTiming, FhirDayOfWeek, FhirPeriodUnit, PrnReasonDefinition, RouteCode, SNOMEDCTRouteCodes } from "./types";
 /**
  * SNOMED CT codings aligned with every known RouteCode. Keeping the structure
  * data-driven ensures any additions to the enumeration are surfaced
@@ -30,8 +30,13 @@ export declare const DEFAULT_BODY_SITE_SNOMED_SOURCE: Array<{
     definition: BodySiteDefinition;
 }>;
 export declare const DEFAULT_BODY_SITE_SNOMED: Record<string, BodySiteDefinition>;
+export declare const DEFAULT_BODY_SITE_HINTS: Set<string>;
 export declare const HOUSEHOLD_VOLUME_UNITS: readonly ["tsp", "tbsp"];
 export declare const DEFAULT_UNIT_SYNONYMS: Record<string, string>;
+export interface ProductFormHint {
+    routeHint?: RouteCode;
+}
+export declare const PRODUCT_FORM_HINTS: Record<string, ProductFormHint>;
 export interface FrequencyDescriptor {
     code?: string;
     frequency?: number;
@@ -71,18 +76,7 @@ export interface PrnReasonDictionaryEntry {
 }
 export declare const DEFAULT_PRN_REASON_ENTRIES: PrnReasonDictionaryEntry[];
 export declare const DEFAULT_PRN_REASON_DEFINITIONS: Record<string, PrnReasonDefinition>;
-export interface AdditionalInstructionDictionaryEntry {
-    canonical: string;
-    definition: AdditionalInstructionDefinition;
-    terms: string[];
-}
-export declare const DEFAULT_ADDITIONAL_INSTRUCTION_ENTRIES: AdditionalInstructionDictionaryEntry[];
-export declare const DEFAULT_ADDITIONAL_INSTRUCTION_DEFINITIONS: Record<string, AdditionalInstructionDefinition>;
 /**
  * Finds a default PRN reason definition by its SNOMED coding.
  */
 export declare function findPrnReasonDefinitionByCoding(system: string, code: string): PrnReasonDefinition | undefined;
-/**
- * Finds a default additional instruction definition by its SNOMED coding.
- */
-export declare function findAdditionalInstructionDefinitionByCoding(system: string, code: string): AdditionalInstructionDefinition | undefined;

package/dist/parser-state.d.ts

@@ -0,0 +1,101 @@
+import { AnnotatedLexToken } from "./lexer/meaning";
+import { CanonicalAdditionalInstructionExpr, CanonicalDoseRange, CanonicalPrnReasonExpr, CanonicalSigClause, EventTiming, FhirCoding, FhirDayOfWeek, FhirPrimitiveElement, FhirPeriodUnit, PrnReasonLookupRequest, PrnReasonSuggestion, RouteCode, SiteCodeLookupRequest, SiteCodeSuggestion } from "./types";
+export interface SiteLookupDetail {
+    request: SiteCodeLookupRequest;
+    suggestions: SiteCodeSuggestion[];
+}
+export interface PrnReasonLookupDetail {
+    request: PrnReasonLookupRequest;
+    suggestions: PrnReasonSuggestion[];
+}
+export interface Token extends AnnotatedLexToken {
+}
+type LocalizedCoding = FhirCoding & {
+    i18n?: Record<string, string>;
+};
+export declare class ParserState {
+    input: string;
+    tokens: Token[];
+    consumed: Set<number>;
+    warnings: string[];
+    siteTokenIndices: Set<number>;
+    siteLookupRequest?: SiteCodeLookupRequest;
+    siteLookups: SiteLookupDetail[];
+    customSiteHints?: Set<string>;
+    prnReasonLookupRequest?: PrnReasonLookupRequest;
+    prnReasonLookups: PrnReasonLookupDetail[];
+    methodVerb?: string;
+    productFormKey?: string;
+    clauses: CanonicalSigClause[];
+    private clause;
+    constructor(input: string, tokens: Token[], customSiteHints?: Set<string>);
+    get primaryClause(): CanonicalSigClause;
+    get dose(): number | undefined;
+    set dose(value: number | undefined);
+    get doseRange(): CanonicalDoseRange | undefined;
+    set doseRange(value: CanonicalDoseRange | undefined);
+    get unit(): string | undefined;
+    set unit(value: string | undefined);
+    get routeCode(): RouteCode | undefined;
+    set routeCode(value: RouteCode | undefined);
+    get routeText(): string | undefined;
+    set routeText(value: string | undefined);
+    get methodText(): string | undefined;
+    set methodText(value: string | undefined);
+    get methodTextElement(): FhirPrimitiveElement | undefined;
+    set methodTextElement(value: FhirPrimitiveElement | undefined);
+    get methodCoding(): LocalizedCoding | undefined;
+    set methodCoding(value: LocalizedCoding | undefined);
+    get count(): number | undefined;
+    set count(value: number | undefined);
+    get duration(): number | undefined;
+    set duration(value: number | undefined);
+    get durationMax(): number | undefined;
+    set durationMax(value: number | undefined);
+    get durationUnit(): FhirPeriodUnit | undefined;
+    set durationUnit(value: FhirPeriodUnit | undefined);
+    get frequency(): number | undefined;
+    set frequency(value: number | undefined);
+    get frequencyMax(): number | undefined;
+    set frequencyMax(value: number | undefined);
+    get period(): number | undefined;
+    set period(value: number | undefined);
+    get periodMax(): number | undefined;
+    set periodMax(value: number | undefined);
+    get periodUnit(): FhirPeriodUnit | undefined;
+    set periodUnit(value: FhirPeriodUnit | undefined);
+    get dayOfWeek(): FhirDayOfWeek[];
+    get when(): EventTiming[];
+    get timeOfDay(): string[] | undefined;
+    set timeOfDay(value: string[] | undefined);
+    get timingCode(): string | undefined;
+    set timingCode(value: string | undefined);
+    get asNeeded(): boolean | undefined;
+    set asNeeded(value: boolean | undefined);
+    get asNeededReason(): string | undefined;
+    set asNeededReason(value: string | undefined);
+    get asNeededReasons(): CanonicalPrnReasonExpr[] | undefined;
+    set asNeededReasons(value: CanonicalPrnReasonExpr[] | undefined);
+    get asNeededReasonCoding(): LocalizedCoding | undefined;
+    set asNeededReasonCoding(value: LocalizedCoding | undefined);
+    get siteText(): string | undefined;
+    set siteText(value: string | undefined);
+    get siteSource(): "abbreviation" | "text" | "selection" | "resolver" | undefined;
+    set siteSource(value: "abbreviation" | "text" | "selection" | "resolver" | undefined);
+    get siteCoding(): LocalizedCoding | undefined;
+    set siteCoding(value: LocalizedCoding | undefined);
+    get additionalInstructions(): CanonicalAdditionalInstructionExpr[];
+    set additionalInstructions(value: CanonicalAdditionalInstructionExpr[]);
+    get patientInstruction(): string | undefined;
+    set patientInstruction(value: string | undefined);
+    private ensureDose;
+    private ensureRoute;
+    private ensureSite;
+    private ensureMethod;
+    private ensureSchedule;
+    private ensurePrn;
+    private cleanupPrn;
+    private cleanupSite;
+    private cleanupMethod;
+}
+export {};

package/dist/parser.d.ts

@@ -1,20 +1,20 @@
-import { ParsedSigInternal, Token } from "./internal-types";
+import { ParserState, Token } from "./parser-state";
 import { ParseOptions, TextRange } from "./types";
 export declare function tokenize(input: string): Token[];
-export declare function findUnparsedTokenGroups(internal: ParsedSigInternal): Array<{
+export declare function findUnparsedTokenGroups(internal: ParserState): Array<{
     tokens: Token[];
     range?: TextRange;
 }>;
-export declare function parseInternal(input: string, options?: ParseOptions): ParsedSigInternal;
+export declare function parseClauseState(input: string, options?: ParseOptions): ParserState;
 /**
  * Resolves parsed site text against SNOMED dictionaries and synchronous
  * callbacks, applying the best match to the in-progress parse result.
  */
-export declare function applyPrnReasonCoding(internal: ParsedSigInternal, options?: ParseOptions): void;
-export declare function applyPrnReasonCodingAsync(internal: ParsedSigInternal, options?: ParseOptions): Promise<void>;
-export declare function applySiteCoding(internal: ParsedSigInternal, options?: ParseOptions): void;
+export declare function applyPrnReasonCoding(internal: ParserState, options?: ParseOptions): void;
+export declare function applyPrnReasonCodingAsync(internal: ParserState, options?: ParseOptions): Promise<void>;
+export declare function applySiteCoding(internal: ParserState, options?: ParseOptions): void;
 /**
  * Asynchronous counterpart to {@link applySiteCoding} that awaits resolver and
  * suggestion callbacks so remote terminology services can be used.
  */
-export declare function applySiteCodingAsync(internal: ParsedSigInternal, options?: ParseOptions): Promise<void>;
+export declare function applySiteCodingAsync(internal: ParserState, options?: ParseOptions): Promise<void>;

package/dist/prn.d.ts

@@ -0,0 +1,4 @@
+import { CanonicalPrnReasonExpr } from "./types";
+export declare function getCanonicalPrnReasonText(reason: CanonicalPrnReasonExpr | undefined): string | undefined;
+export declare function joinCanonicalPrnReasonTexts(reasons: CanonicalPrnReasonExpr[] | undefined, conjunction?: string): string | undefined;
+export declare function getPreferredCanonicalPrnReasonText(reason: CanonicalPrnReasonExpr | undefined, reasons: CanonicalPrnReasonExpr[] | undefined, conjunction?: string): string | undefined;

package/dist/site-phrases.d.ts

@@ -0,0 +1,35 @@
+import { Token } from "./parser-state";
+import { BodySiteDefinition, ParseOptions, RouteCode } from "./types";
+export interface SitePhraseServices {
+    customSiteHints?: Set<string>;
+    siteConnectors: ReadonlySet<string>;
+    siteFillerWords: ReadonlySet<string>;
+    isInstructionLikeText?: (text: string) => boolean;
+    normalizeTokenLower: (token: Token) => string;
+    isBodySiteHint: (word: string, customSiteHints?: Set<string>) => boolean;
+    hasExplicitSiteIntroduction: (startIndex: number) => boolean;
+    isNumericToken: (value: string) => boolean;
+    isOrdinalToken: (value: string) => boolean;
+    mapFrequencyAdverb: (value: string) => string | undefined;
+    mapIntervalUnit: (value: string) => string | undefined;
+    normalizeUnit: (value: string, options?: ParseOptions) => string | undefined;
+    hasRouteLikeWord: (value: string, options?: ParseOptions) => boolean;
+    hasFrequencyLikeWord: (value: string) => boolean;
+    getNextActiveToken: (index: number) => Token | undefined;
+    getPreviousActiveToken: (index: number) => Token | undefined;
+    hasApplicationVerbBefore: (index: number) => boolean;
+}
+export interface SiteLookupServices {
+    lookupBodySiteDefinition: (map: Record<string, BodySiteDefinition> | undefined, canonical: string) => BodySiteDefinition | undefined;
+}
+export interface SitePhraseCandidate {
+    tokenIndices: number[];
+    source: "explicit" | "residual";
+}
+export declare function isTimingOnlySitePhrase(words: string[]): boolean;
+export declare function hasExternalSurfaceModifier(siteText: string): boolean;
+export declare function extractExplicitSiteCandidate(tokens: Token[], consumed: Set<number>, startIndex: number, options: ParseOptions | undefined, services: SitePhraseServices): SitePhraseCandidate | undefined;
+export declare function selectBestResidualSiteCandidate(groups: Array<{
+    tokens: Token[];
+}>, prnSiteSuffixIndices: Set<number>, services: SitePhraseServices): SitePhraseCandidate | undefined;
+export declare function inferRouteHintFromSitePhrase(siteText: string, options: ParseOptions | undefined, services: SiteLookupServices): RouteCode | undefined;

package/dist/timing-summary.d.ts

@@ -1,5 +1,4 @@
-import { ParsedSigInternal } from "./internal-types";
-import { EventTiming } from "./types";
+import { EventTiming, FhirDayOfWeek, FhirPeriodUnit } from "./types";
 export interface TimingSummaryOptions {
     groupMealTimingsByRelation?: boolean;
     includeTimesPerDaySummary?: boolean;
@@ -11,5 +10,16 @@ export interface MealTimingGroup {
     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(internal: ParsedSigInternal, options?: TimingSummaryOptions): number | undefined;
+export declare function inferDailyOccurrenceCount(input: TimingSummaryInput, options?: TimingSummaryOptions): number | undefined;