ezmedicationinput 0.1.44 → 0.1.46

package/dist/hpsg/rule-context.d.ts

@@ -0,0 +1,32 @@
+import { Token, ParserState } from "../parser-state";
+import { ParseOptions } from "../types";
+import { HpsgLexicalRule } from "./signature";
+import { HpsgProjectionDeps } from "./projection";
+import { HpsgUnificationContext } from "./unification";
+export interface HpsgClauseContext {
+    state: ParserState;
+    tokens: Token[];
+    options?: ParseOptions;
+    limit: number;
+    deps: HpsgProjectionDeps & HpsgUnificationContext;
+    project?: boolean;
+}
+export declare function normalizeTokenLower(token: Token): string;
+export declare function isPunctuation(lower: string): boolean;
+export declare function isClockLikeLower(lower: string): boolean;
+export declare function isAmPmLower(lower: string): boolean;
+export declare function isAnteMeridiemLower(lower: string): boolean;
+export declare function isPostMeridiemLower(lower: string): boolean;
+export declare function parseClockToken(token: Token | undefined, meridiemToken?: Token | undefined): {
+    value: string;
+    tokens: Token[];
+} | undefined;
+export declare function tokensAvailable(context: HpsgClauseContext, start: number, span: number): Token[] | undefined;
+export declare function rangeFromTokens(tokens: Token[]): {
+    start: number;
+    end: number;
+} | undefined;
+export declare function splitByLexicalSeparators(text: string, separators: ReadonlySet<string>): string[];
+export declare function hasLexicalSeparator(text: string, separators: ReadonlySet<string>): boolean;
+export declare function joinTokenText(tokens: Token[]): string;
+export declare function lexicalRule(id: string, match: HpsgLexicalRule<HpsgClauseContext>["match"]): HpsgLexicalRule<HpsgClauseContext>;

package/dist/hpsg/rules/core-rules.d.ts

@@ -0,0 +1,8 @@
+import { HpsgClauseContext } from "../rule-context";
+import { HpsgLexicalRule } from "../signature";
+export declare function methodLexicalRule(): HpsgLexicalRule<HpsgClauseContext>;
+export declare function routeLexicalRule(): HpsgLexicalRule<HpsgClauseContext>;
+export declare function fillerLexicalRule(): HpsgLexicalRule<HpsgClauseContext>;
+export declare function productLexicalRule(): HpsgLexicalRule<HpsgClauseContext>;
+export declare function doseLexicalRule(): HpsgLexicalRule<HpsgClauseContext>;
+export declare function connectorLexicalRule(): HpsgLexicalRule<HpsgClauseContext>;

package/dist/hpsg/rules/instruction-rules.d.ts

@@ -0,0 +1,4 @@
+import { HpsgClauseContext } from "../rule-context";
+import { HpsgLexicalRule } from "../signature";
+export declare function workflowLexicalRule(): HpsgLexicalRule<HpsgClauseContext>;
+export declare function instructionLexicalRule(): HpsgLexicalRule<HpsgClauseContext>;

package/dist/hpsg/rules/prn-rules.d.ts

@@ -0,0 +1,3 @@
+import { HpsgClauseContext } from "../rule-context";
+import { HpsgLexicalRule } from "../signature";
+export declare function prnLexicalRule(): HpsgLexicalRule<HpsgClauseContext>;

package/dist/hpsg/rules/product-route.d.ts

@@ -0,0 +1,2 @@
+import { RouteCode } from "../../types";
+export declare function productRouteHint(phrase: string | undefined): RouteCode | undefined;

package/dist/hpsg/rules/site-rules.d.ts

@@ -0,0 +1,4 @@
+import { HpsgClauseContext } from "../rule-context";
+import { HpsgLexicalRule } from "../signature";
+export declare function siteLexicalRule(): HpsgLexicalRule<HpsgClauseContext>;
+export declare function bareSiteLexicalRule(): HpsgLexicalRule<HpsgClauseContext>;

package/dist/hpsg/rules/timing-rules.d.ts

@@ -0,0 +1,12 @@
+import { HpsgClauseContext } from "../rule-context";
+import { HpsgLexicalRule } from "../signature";
+export declare function multiplicativeDoseFrequencyRule(): HpsgLexicalRule<HpsgClauseContext>;
+export declare function compactIntervalRule(): HpsgLexicalRule<HpsgClauseContext>;
+export declare function separatedIntervalRule(): HpsgLexicalRule<HpsgClauseContext>;
+export declare function countFrequencyRule(): HpsgLexicalRule<HpsgClauseContext>;
+export declare function timingLexicalRule(): HpsgLexicalRule<HpsgClauseContext>;
+export declare function eventTimingPhraseRule(): HpsgLexicalRule<HpsgClauseContext>;
+export declare function dayRangeLexicalRule(): HpsgLexicalRule<HpsgClauseContext>;
+export declare function countAndDurationRule(): HpsgLexicalRule<HpsgClauseContext>;
+export declare function timeOfDayRule(): HpsgLexicalRule<HpsgClauseContext>;
+export declare function isScheduleLead(context: HpsgClauseContext, index: number): boolean;

package/dist/hpsg/segmenter.d.ts

@@ -0,0 +1,6 @@
+export interface HpsgSigSegment {
+    text: string;
+    start: number;
+    end: number;
+}
+export declare function parseSigSegments(input: string): HpsgSigSegment[];

package/dist/hpsg/signature.d.ts

@@ -0,0 +1,116 @@
+import { CanonicalDoseRange, CanonicalAdditionalInstructionExpr, BodySiteSpatialRelation, EventTiming, FhirCoding, FhirDayOfWeek, FhirPeriodUnit, FhirPrimitiveElement, RouteCode, PrnReasonLookupRequest, SiteCodeLookupRequest } from "../types";
+import { Token } from "../parser-state";
+export type HpsgType = "sign" | "word-sign" | "phrase-sign" | "clause-sign" | "method-sign" | "route-sign" | "site-sign" | "dose-sign" | "schedule-sign" | "prn-sign" | "instruction-sign" | "connector-sign";
+export interface HpsgEvidence {
+    rule: string;
+    tokenIndices: number[];
+}
+export interface HpsgMethodFeature {
+    verb: string;
+    text?: string;
+    textElement?: FhirPrimitiveElement;
+    coding?: FhirCoding;
+}
+export interface HpsgRouteFeature {
+    code: RouteCode;
+    text?: string;
+}
+export interface HpsgSiteFeature {
+    text?: string;
+    source?: "abbreviation" | "text" | "selection" | "resolver";
+    coding?: FhirCoding;
+    spatialRelation?: BodySiteSpatialRelation;
+    lookupRequest?: SiteCodeLookupRequest;
+}
+export interface HpsgPrnFeature {
+    enabled: true;
+    reasonText?: string;
+    lookupRequest?: PrnReasonLookupRequest;
+    reasons?: Array<{
+        text: string;
+        lookupRequest?: PrnReasonLookupRequest;
+    }>;
+    lookupRequests?: PrnReasonLookupRequest[];
+}
+export interface HpsgInstructionFeature extends CanonicalAdditionalInstructionExpr {
+}
+export interface HpsgPatientInstructionFeature {
+    text: string;
+}
+export interface HpsgDoseFeature {
+    value?: number;
+    range?: CanonicalDoseRange;
+    unit?: string;
+}
+export interface HpsgScheduleFeature {
+    timingCode?: string;
+    count?: number;
+    duration?: number;
+    durationMax?: number;
+    durationUnit?: FhirPeriodUnit;
+    frequency?: number;
+    frequencyMax?: number;
+    period?: number;
+    periodMax?: number;
+    periodUnit?: FhirPeriodUnit;
+    when?: EventTiming[];
+    dayOfWeek?: FhirDayOfWeek[];
+    timeOfDay?: string[];
+}
+export interface HpsgSynsem {
+    head: {
+        method?: HpsgMethodFeature;
+        route?: HpsgRouteFeature;
+        dose?: HpsgDoseFeature;
+        schedule?: HpsgScheduleFeature;
+    };
+    valence: {
+        site?: HpsgSiteFeature;
+        prn?: HpsgPrnFeature;
+        instructions?: HpsgInstructionFeature[];
+        patientInstruction?: HpsgPatientInstructionFeature;
+    };
+    cont: {
+        clauseKind?: "administration";
+    };
+}
+export interface HpsgSign {
+    type: HpsgType;
+    span: {
+        start: number;
+        end: number;
+    };
+    tokens: Token[];
+    synsem: HpsgSynsem;
+    consumedTokenIndices: number[];
+    siteTokenIndices?: number[];
+    warnings?: string[];
+    evidence: HpsgEvidence[];
+    score: number;
+}
+export interface HpsgLexicalRule<TContext> {
+    id: string;
+    type: HpsgType;
+    match(context: TContext, start: number): HpsgSign[];
+}
+export interface HpsgPhraseRule<TContext> {
+    id: string;
+    left?: HpsgType;
+    right?: HpsgType;
+    combine(context: TContext, left: HpsgSign, right: HpsgSign): HpsgSign | undefined;
+}
+export interface HpsgGrammar<TContext> {
+    lexicalRules: HpsgLexicalRule<TContext>[];
+    phraseRules: HpsgPhraseRule<TContext>[];
+}
+export declare function emptySynsem(): HpsgSynsem;
+export declare function lexicalSign(args: {
+    type: HpsgType;
+    rule: string;
+    tokens: Token[];
+    synsem: HpsgSynsem;
+    consumedTokenIndices?: number[];
+    siteTokenIndices?: number[];
+    warnings?: string[];
+    score?: number;
+}): HpsgSign;

package/dist/hpsg/timing-lexicon.d.ts

@@ -0,0 +1,31 @@
+import { ParserState } from "../parser-state";
+import { FhirPeriodUnit } from "../types";
+import { HpsgScheduleFeature } from "./signature";
+export declare const EVERY_INTERVAL_TOKENS: Set<string>;
+export declare const COUNT_MARKER_TOKENS: Set<string>;
+export declare const COUNT_CONNECTOR_WORDS: Set<string>;
+export declare const FREQUENCY_SIMPLE_WORDS: Record<string, number>;
+export declare const FREQUENCY_NUMBER_WORDS: Record<string, number>;
+export declare const FREQUENCY_TIMES_WORDS: Set<string>;
+export declare const FREQUENCY_CONNECTOR_WORDS: Set<string>;
+export declare function normalizePeriodValue(value: number, unit: FhirPeriodUnit): {
+    value: number;
+    unit: FhirPeriodUnit;
+};
+export declare function normalizePeriodRange(low: number, high: number, unit: FhirPeriodUnit): {
+    low: number;
+    high: number;
+    unit: FhirPeriodUnit;
+};
+export declare function periodUnitSuffix(unit: FhirPeriodUnit): string | undefined;
+export declare function applyPeriod(internal: ParserState, period: number, unit: FhirPeriodUnit): void;
+export declare function buildPeriodScheduleFeature(period: number, unit: FhirPeriodUnit): HpsgScheduleFeature;
+export declare function mapIntervalUnit(token: string): FhirPeriodUnit.Minute | FhirPeriodUnit.Hour | FhirPeriodUnit.Day | FhirPeriodUnit.Week | FhirPeriodUnit.Month | undefined;
+export declare function mapFrequencyAdverb(token: string): FhirPeriodUnit | undefined;
+export declare function parseNumericRange(token: string): {
+    low: number;
+    high: number;
+} | undefined;
+export declare function normalizeCountLimitValue(value: number | undefined): number | undefined;
+export declare function applyDurationLimit(internal: ParserState, value: number | undefined, unit: FhirPeriodUnit | undefined, max?: number): boolean;
+export declare function buildDurationScheduleFeature(value: number | undefined, unit: FhirPeriodUnit | undefined, max?: number): HpsgScheduleFeature | undefined;

package/dist/hpsg/unification.d.ts

@@ -0,0 +1,8 @@
+import { HpsgSign, HpsgSynsem } from "./signature";
+import { RouteCode } from "../types";
+export interface HpsgUnificationContext {
+    normalizeSiteText(text: string): string;
+    isCompatibleRouteRefinement(current: RouteCode | undefined, next: RouteCode): boolean;
+}
+export declare function unifySynsem(left: HpsgSynsem, right: HpsgSynsem, context: HpsgUnificationContext): HpsgSynsem | undefined;
+export declare function combineSigns(left: HpsgSign, right: HpsgSign, context: HpsgUnificationContext, rule: string): HpsgSign | undefined;