@atomic-ehr/fhirpath 0.0.1-canary.35b105d.20250724165800

package/src/lexer/token.ts

@@ -0,0 +1,104 @@
+export enum TokenType {
+  // Literals
+  LITERAL = 'LITERAL',            // Generic literal token for registry-based literals
+  NULL = 'NULL',                  // {} (nullLiteral in grammar)
+  TRUE = 'TRUE',                  // true
+  FALSE = 'FALSE',                // false
+  STRING = 'STRING',              // 'string value'
+  NUMBER = 'NUMBER',              // 123, 45.67, 0123 (allows leading zeros)
+  DATE = 'DATE',                  // @2024, @2024-01, @2024-01-15
+  DATETIME = 'DATETIME',          // @2024-01-15T10:30:00Z
+  TIME = 'TIME',                  // @T14:30:00
+  
+  // Identifiers
+  IDENTIFIER = 'IDENTIFIER',      // [A-Za-z_][A-Za-z0-9_]*
+  DELIMITED_IDENTIFIER = 'DELIMITED_IDENTIFIER', // `identifier`
+  
+  // Special variables
+  THIS = 'THIS',                  // $this
+  INDEX = 'INDEX',                // $index
+  TOTAL = 'TOTAL',                // $total
+  
+  // Environment variables
+  ENV_VAR = 'ENV_VAR',           // %context, %`vs-name`
+  
+  // Operators (by precedence)
+  DOT = 'DOT',                   // .
+  LBRACKET = 'LBRACKET',         // [
+  RBRACKET = 'RBRACKET',         // ]
+  LPAREN = 'LPAREN',             // (
+  RPAREN = 'RPAREN',             // )
+  
+  // Arithmetic
+  PLUS = 'PLUS',                 // +
+  MINUS = 'MINUS',               // -
+  STAR = 'STAR',                 // *
+  SLASH = 'SLASH',               // /
+  DIV = 'DIV',                   // div
+  MOD = 'MOD',                   // mod
+  CONCAT = 'CONCAT',             // &
+  
+  // Type operators
+  IS = 'IS',                     // is
+  AS = 'AS',                     // as
+  
+  // Union
+  PIPE = 'PIPE',                 // |
+  
+  // Comparison
+  LT = 'LT',                     // <
+  LTE = 'LTE',                   // <=
+  GT = 'GT',                     // >
+  GTE = 'GTE',                   // >=
+  EQ = 'EQ',                     // =
+  NEQ = 'NEQ',                   // !=
+  EQUIV = 'EQUIV',               // ~
+  NEQUIV = 'NEQUIV',             // !~
+  
+  // Membership
+  IN = 'IN',                     // in
+  CONTAINS = 'CONTAINS',         // contains
+  
+  // Boolean
+  AND = 'AND',                   // and
+  OR = 'OR',                     // or
+  XOR = 'XOR',                   // xor
+  IMPLIES = 'IMPLIES',           // implies
+  NOT = 'NOT',                   // not
+  
+  // Collection
+  LBRACE = 'LBRACE',             // {
+  RBRACE = 'RBRACE',             // }
+  
+  // Other
+  COMMA = 'COMMA',               // ,
+  EOF = 'EOF',
+  
+  // Units (for quantities)
+  UNIT = 'UNIT',                 // year, month, 'mg', etc.
+  
+  // Trivia tokens (when preserving whitespace/comments)
+  WS = 'WS',                     // Whitespace
+  COMMENT = 'COMMENT',           // /* Multi-line comment */
+  LINE_COMMENT = 'LINE_COMMENT', // // Single-line comment
+}
+
+export interface Position {
+  line: number;
+  column: number;
+  offset: number;
+}
+
+export enum Channel {
+  DEFAULT = 0,
+  HIDDEN = 1    // For whitespace and comments
+}
+
+export interface Token {
+  type: TokenType;
+  value: string;
+  position: Position;
+  channel?: Channel;  // Optional channel for trivia
+  operation?: any;    // Operation from registry (using any to avoid circular dependency)
+  literalValue?: any; // Parsed literal value for LITERAL tokens
+}

package/src/parser/ast.ts

@@ -0,0 +1,123 @@
+import type { TokenType } from '../lexer/token';
+
+// Core AST Node Interface
+export interface ASTNode {
+  type: NodeType;
+  position: Position;
+  // Type analysis fields (optional - added by analyzer)
+  resultType?: unknown;  // Opaque type reference
+  isSingleton?: boolean; // Whether this expression returns a single value
+}
+
+export interface Position {
+  line: number;
+  column: number;
+  offset: number;
+}
+
+// Node types
+export enum NodeType {
+  // Navigation
+  Identifier,
+  TypeOrIdentifier, // Uppercase identifiers that could be types (Patient, Observation)
+  
+  // Operators
+  Binary,     // All binary operators including dot
+  Unary,      // unary +, -, not
+  Union,      // | operator (special handling for multiple operands)
+  
+  // Functions
+  Function,   // Function calls
+  
+  // Literals
+  Literal,    // numbers, strings, booleans, dates, null
+  Variable,   // $this, $index, $total, %var
+  Collection, // {} empty collection or {expr1, expr2, ...}
+  
+  // Type operations
+  MembershipTest, // 'is' operator
+  TypeCast,       // 'as' operator
+  TypeReference,  // Type name in ofType()
+  
+  // Special
+  Index,      // [] indexing
+}
+
+// Specific node types
+export interface IdentifierNode extends ASTNode {
+  type: NodeType.Identifier;
+  name: string;
+}
+
+export interface TypeOrIdentifierNode extends ASTNode {
+  type: NodeType.TypeOrIdentifier;
+  name: string;
+}
+
+export interface LiteralNode extends ASTNode {
+  type: NodeType.Literal;
+  value: any;
+  valueType: 'string' | 'number' | 'boolean' | 'date' | 'time' | 'datetime' | 'null';
+  raw?: string;        // Raw string representation
+  operation?: any;     // Operation from registry (using any to avoid circular dependency)
+}
+
+export interface BinaryNode extends ASTNode {
+  type: NodeType.Binary;
+  operator: TokenType;
+  operation?: any;     // Operation from registry (using any to avoid circular dependency)
+  left: ASTNode;
+  right: ASTNode;
+}
+
+export interface UnaryNode extends ASTNode {
+  type: NodeType.Unary;
+  operator: TokenType;
+  operation?: any;     // Operation from registry (using any to avoid circular dependency)
+  operand: ASTNode;
+}
+
+export interface FunctionNode extends ASTNode {
+  type: NodeType.Function;
+  name: ASTNode;  // Usually an identifier
+  arguments: ASTNode[];
+  operation?: any;     // Operation from registry (using any to avoid circular dependency)
+}
+
+export interface VariableNode extends ASTNode {
+  type: NodeType.Variable;
+  name: string;
+}
+
+export interface IndexNode extends ASTNode {
+  type: NodeType.Index;
+  expression: ASTNode;
+  index: ASTNode;
+}
+
+export interface UnionNode extends ASTNode {
+  type: NodeType.Union;
+  operands: ASTNode[];
+}
+
+export interface MembershipTestNode extends ASTNode {
+  type: NodeType.MembershipTest;
+  expression: ASTNode;
+  targetType: string;
+}
+
+export interface TypeCastNode extends ASTNode {
+  type: NodeType.TypeCast;
+  expression: ASTNode;
+  targetType: string;
+}
+
+export interface CollectionNode extends ASTNode {
+  type: NodeType.Collection;
+  elements: ASTNode[];
+}
+
+export interface TypeReferenceNode extends ASTNode {
+  type: NodeType.TypeReference;
+  typeName: string;
+}

package/src/parser/index.ts

@@ -0,0 +1,3 @@
+export { FHIRPathParser, ParseError, parse } from './parser';
+export * from './ast';
+export { pprint } from './pprint';