@atomic-ehr/fhirpath 0.0.1 → 0.0.2-canary.3157434.20250804172319

package/README.md

@@ -1,5 +1,7 @@
 # @atomic-ehr/fhirpath
 
+[![npm version](https://badge.fury.io/js/@atomic-ehr%2Ffhirpath.svg)](https://www.npmjs.com/package/@atomic-ehr/fhirpath)
+
 A TypeScript implementation of FHIRPath, the path-based navigation and extraction language for FHIR (Fast Healthcare Interoperability Resources).
 
 ## Installation

package/dist/index.d.ts

@@ -1,5 +1,37 @@
 import { FHIRSchema } from '@atomic-ehr/fhirschema';
 
+/**
+ * Symbol to mark boxed values
+ */
+declare const BOXED_SYMBOL: unique symbol;
+/**
+ * Extension structure for FHIR primitive elements
+ */
+interface Extension {
+    url: string;
+    [key: string]: any;
+}
+/**
+ * Metadata for FHIR primitive elements (e.g., _gender for gender property)
+ */
+interface PrimitiveElement {
+    id?: string;
+    extension?: Extension[];
+}
+/**
+ * Boxed FHIRPath value with metadata
+ */
+interface FHIRPathValue<T = any> {
+    /** The actual value */
+    value: T;
+    /** Type information from ModelProvider */
+    typeInfo?: TypeInfo;
+    /** Primitive element extension (for primitives only) */
+    primitiveElement?: PrimitiveElement;
+    /** Internal marker to identify boxed values */
+    [BOXED_SYMBOL]: true;
+}
+
 /**
  * Simplified FHIRPath Lexer
  *
@@ -303,7 +335,7 @@ interface RuntimeContext {
     variables: Record<string, any>;
 }
 interface EvaluationResult {
-    value: any[];
+    value: FHIRPathValue[];
     context: RuntimeContext;
 }
 declare enum DiagnosticSeverity {
@@ -346,51 +378,8 @@ interface ParseResult {
         availableCompletions: string[];
     };
 }
-type OperationEvaluator = (input: any[], context: RuntimeContext, ...args: any[]) => EvaluationResult;
-type FunctionEvaluator = (input: any[], context: RuntimeContext, args: ASTNode[], evaluator: (node: ASTNode, input: any[], context: RuntimeContext) => EvaluationResult) => EvaluationResult;
-
-/**
- * Abstract base parser with shared parsing logic
- * Subclasses must implement node creation and error handling
- */
-declare abstract class BaseParser<TNode extends BaseASTNode = BaseASTNode> {
-    protected lexer: Lexer;
-    protected tokens: Token[];
-    protected current: number;
-    constructor(input: string, lexerOptions?: LexerOptions);
-    protected abstract createIdentifierNode(name: string, token: Token): TNode;
-    protected abstract createLiteralNode(value: any, valueType: 'string' | 'number' | 'boolean' | 'date' | 'time' | 'datetime' | 'null', token: Token): TNode;
-    protected abstract createBinaryNode(token: Token, left: TNode, right: TNode): TNode;
-    protected abstract createUnaryNode(token: Token, operand: TNode): TNode;
-    protected abstract createFunctionNode(name: TNode, args: TNode[], startToken: Token): TNode;
-    protected abstract createVariableNode(name: string, token: Token): TNode;
-    protected abstract createIndexNode(expression: TNode, index: TNode, startToken: Token): TNode;
-    protected abstract createMembershipTestNode(expression: TNode, targetType: string, startToken: Token): TNode;
-    protected abstract createTypeCastNode(expression: TNode, targetType: string, startToken: Token): TNode;
-    protected abstract createCollectionNode(elements: TNode[], startToken: Token): TNode;
-    protected abstract createQuantityNode(value: number, unit: string, isCalendarUnit: boolean, startToken: Token, endToken: Token): TNode;
-    protected abstract handleError(message: string, token?: Token): never | TNode;
-    protected expression(): TNode;
-    protected parseExpressionWithPrecedence(minPrecedence: number): TNode;
-    protected parsePrimary(): TNode;
-    protected parseInvocation(): TNode;
-    protected parseArgumentList(): TNode[];
-    protected parseCollectionElements(): TNode[];
-    protected parseTypeName(): string;
-    protected parseStringValue(raw: string): string;
-    protected parseIdentifierValue(raw: string): string;
-    protected isFunctionCall(node: TNode): boolean;
-    protected isBinaryOperatorToken(token: Token): boolean;
-    protected isKeywordAllowedAsMember(token: Token): boolean;
-    protected isKeywordAllowedAsIdentifier(token: Token): boolean;
-    protected peek(): Token;
-    protected previous(): Token;
-    protected isAtEnd(): boolean;
-    protected advance(): Token;
-    protected check(type: TokenType): boolean;
-    protected match(...types: TokenType[]): boolean;
-    protected consume(type: TokenType, message: string): Token;
-}
+type OperationEvaluator = (input: FHIRPathValue[], context: RuntimeContext, ...args: any[]) => EvaluationResult;
+type FunctionEvaluator = (input: FHIRPathValue[], context: RuntimeContext, args: ASTNode[], evaluator: (node: ASTNode, input: FHIRPathValue[], context: RuntimeContext) => EvaluationResult) => EvaluationResult;
 
 interface ParserOptions {
     mode?: 'simple' | 'lsp';
@@ -401,7 +390,10 @@ interface ParserOptions {
         cursorPosition: number;
     };
 }
-declare class Parser extends BaseParser<ASTNode> {
+declare class Parser {
+    protected lexer: Lexer;
+    protected tokens: Token[];
+    protected current: number;
     private mode;
     private options;
     private errors?;
@@ -419,6 +411,26 @@ declare class Parser extends BaseParser<ASTNode> {
     parse(): ParseResult;
     private parseSimple;
     private parseLSP;
+    protected expression(): ASTNode;
+    protected parseExpressionWithPrecedence(minPrecedence: number): ASTNode;
+    protected parsePrimary(): ASTNode;
+    protected parseInvocation(): ASTNode;
+    protected parseArgumentList(): ASTNode[];
+    protected parseCollectionElements(): ASTNode[];
+    protected parseTypeName(): string;
+    protected parseStringValue(raw: string): string;
+    protected parseIdentifierValue(raw: string): string;
+    protected isFunctionCall(node: ASTNode): boolean;
+    protected isBinaryOperatorToken(token: Token): boolean;
+    protected isKeywordAllowedAsMember(token: Token): boolean;
+    protected isKeywordAllowedAsIdentifier(token: Token): boolean;
+    protected peek(): Token;
+    protected previous(): Token;
+    protected isAtEnd(): boolean;
+    protected advance(): Token;
+    protected check(type: TokenType): boolean;
+    protected match(...types: TokenType[]): boolean;
+    protected consume(type: TokenType, message: string): Token;
     protected createIdentifierNode(name: string, token: Token): ASTNode;
     protected createLiteralNode(value: any, valueType: LiteralNode['valueType'], token: Token): LiteralNode;
     protected createBinaryNode(token: Token, left: ASTNode, right: ASTNode): BinaryNode;