@atomic-ehr/fhirpath 0.0.2 → 0.0.3

package/src/operations/unary-minus-operator.ts

@@ -1,8 +1,8 @@
 import type { OperatorDefinition } from '../types';
 import { PRECEDENCE } from '../types';
 import type { OperationEvaluator } from '../types';
-import type { QuantityValue } from '../quantity-value';
-import { box, unbox } from '../boxing';
+import type { QuantityValue } from '../complex-types/quantity-value';
+import { box, unbox } from '../interpreter/boxing';
 
 export const evaluate: OperationEvaluator = async (input, context, operand) => {
   // Unary minus negates each boxed value

package/src/operations/unary-plus-operator.ts

@@ -1,7 +1,7 @@
 import type { OperatorDefinition } from '../types';
 import { PRECEDENCE } from '../types';
 import type { OperationEvaluator } from '../types';
-import { box, unbox } from '../boxing';
+import { box, unbox } from '../interpreter/boxing';
 
 export const evaluate: OperationEvaluator = async (input, context, operand) => {
   // Unary plus returns the operand as-is

package/src/operations/union-function.ts

@@ -1,6 +1,6 @@
 import type { FunctionDefinition, FunctionEvaluator } from '../types';
 import { Errors } from '../errors';
-import { box, unbox } from '../boxing';
+import { box, unbox } from '../interpreter/boxing';
 
 export const evaluate: FunctionEvaluator = async (input, context, args, evaluator) => {
   if (args.length !== 1) {

package/src/operations/union-operator.ts

@@ -1,45 +1,35 @@
 import type { OperatorDefinition } from '../types';
 import { PRECEDENCE } from '../types';
 import type { OperationEvaluator } from '../types';
-import { box, unbox } from '../boxing';
+import { box, unbox } from '../interpreter/boxing';
+import { evaluate as equalsEvaluate } from './equal-operator';
+import { Errors } from '../errors';
 
 // Note: The union operator is special and is typically handled directly in the interpreter
 // because it needs to preserve the original context for both operands
 export const evaluate: OperationEvaluator = async (input, context, left, right) => {
-  // Union merges collections and eliminates duplicates using equals (=) operator
+  // '|' deduplicates using equals (=) semantics
   const result: any[] = [];
-  const seen = new Set<any>();
-  
-  // Add items from left collection
-  for (const item of left) {
-    let isDuplicate = false;
+  const isDup = async (candidate: any): Promise<boolean> => {
     for (const existing of result) {
-      // Use equals operator semantics for duplicate detection
-      if (existing === item) {
-        isDuplicate = true;
-        break;
+      const eq = await equalsEvaluate(input, context, [existing], [candidate]);
+      const v = eq.value[0];
+      if (v && typeof v.value === 'boolean' && v.value === true) {
+        return true;
       }
     }
-    if (!isDuplicate) {
+    return false;
+  };
+  for (const item of left) {
+    if (!(await isDup(item))) {
       result.push(item);
     }
   }
-  
-  // Add items from right collection if not already present
   for (const item of right) {
-    let isDuplicate = false;
-    for (const existing of result) {
-      // Use equals operator semantics for duplicate detection
-      if (existing === item) {
-        isDuplicate = true;
-        break;
-      }
-    }
-    if (!isDuplicate) {
+    if (!(await isDup(item))) {
       result.push(item);
     }
   }
-  
   return { value: result, context };
 };
 
@@ -49,7 +39,7 @@ export const unionOperator: OperatorDefinition & { evaluate: OperationEvaluator
   category: ['collection'],
   precedence: PRECEDENCE.PIPE,
   associativity: 'left',
-  description: 'Merges two collections into a single collection, eliminating any duplicate values using the equals (=) operator. There is no expectation of order in the resulting collection',
+  description: 'Merges two collections into a single collection, eliminating duplicates using equals (=) semantics. Order is not guaranteed.',
   examples: [
     'name.given | name.family',
     'Patient.identifier | Patient.contact.identifier',
@@ -65,4 +55,4 @@ export const unionOperator: OperatorDefinition & { evaluate: OperationEvaluator
     }
   ],
   evaluate
-};
+};

package/src/operations/upper-function.ts

@@ -1,6 +1,6 @@
 import type { FunctionDefinition, FunctionEvaluator } from '../types';
 import { Errors } from '../errors';
-import { box, unbox } from '../boxing';
+import { box, unbox } from '../interpreter/boxing';
 
 export const evaluate: FunctionEvaluator = async (input, context, args, evaluator) => {
   // Handle empty input collection

package/src/operations/where-function.ts

@@ -1,7 +1,7 @@
 import type { FunctionDefinition, ASTNode } from '../types';
-import { RuntimeContextManager } from '../interpreter';
+import { RuntimeContextManager } from '../interpreter/runtime-context';
 import { type FunctionEvaluator } from '../types';
-import { unbox } from '../boxing';
+import { unbox } from '../interpreter/boxing';
 
 export const evaluate: FunctionEvaluator = async (input, context, args, evaluator) => {
   // If no condition provided, return input as-is
@@ -58,4 +58,4 @@ export const whereFunction: FunctionDefinition & { evaluate: FunctionEvaluator }
     result: 'inputType' as any,
   }],
   evaluate
-};
+};

package/src/operations/xor-operator.ts

@@ -1,7 +1,7 @@
 import type { OperatorDefinition } from '../types';
 import { PRECEDENCE } from '../types';
 import type { OperationEvaluator } from '../types';
-import { box, unbox } from '../boxing';
+import { box, unbox } from '../interpreter/boxing';
 
 export const evaluate: OperationEvaluator = async (input, context, left, right) => {
   // Three-valued logic for XOR

package/src/operations/yearOf-function.ts

@@ -0,0 +1,66 @@
+// yearOf() function - Extracts year component from Date or DateTime
+import type { FunctionDefinition, FunctionEvaluator } from '../types';
+import { box, unbox } from '../interpreter/boxing';
+import { isFHIRDate, isFHIRDateTime } from '../complex-types/temporal';
+import { Errors } from '../errors';
+
+export const yearOfEvaluator: FunctionEvaluator = async (input, context, args) => {
+  // yearOf() takes no arguments
+  if (args.length !== 0) {
+    throw Errors.wrongArgumentCount('yearOf', 0, args.length);
+  }
+  
+  // Empty input returns empty
+  if (input.length === 0) {
+    return { value: [], context };
+  }
+  
+  // Multiple items throws error
+  if (input.length > 1) {
+    throw Errors.singletonRequired('yearOf', input.length);
+  }
+  
+  const boxedValue = input[0];
+  if (!boxedValue) {
+    return { value: [], context };
+  }
+  
+  const value = unbox(boxedValue);
+  
+  // Check if it's a Date or DateTime
+  if (isFHIRDate(value) || isFHIRDateTime(value)) {
+    // Check if year component is present
+    if (value.year === undefined) {
+      return { value: [], context };
+    }
+    
+    // Return the year as an Integer
+    return {
+      value: [box(value.year, { type: 'Integer', singleton: true })],
+      context
+    };
+  }
+  
+  // Not a Date or DateTime, return empty
+  return { value: [], context };
+};
+
+export const yearOfFunction: FunctionDefinition & { evaluate: typeof yearOfEvaluator } = {
+  name: 'yearOf',
+  category: ['temporal'],
+  description: 'Returns the year component of a Date or DateTime value',
+  examples: [
+    '@2014-01-05.yearOf()',
+    '@2014-01-05T10:30:00.yearOf()',
+    'Patient.birthDate.yearOf()'
+  ],
+  signatures: [
+    {
+      name: 'yearOf',
+      input: { type: 'Any', singleton: true },
+      parameters: [],
+      result: { type: 'Integer', singleton: true }
+    }
+  ],
+  evaluate: yearOfEvaluator
+};

package/src/{cursor-nodes.ts → parser/cursor-nodes.ts}

@@ -1,3 +1,5 @@
+import type { BaseASTNode } from '../types';
+
 export enum CursorContext {
   Operator = 'operator',
   Identifier = 'identifier',
@@ -6,14 +8,10 @@ export enum CursorContext {
   Type = 'type',
 }
 
-export interface CursorNode {
+export interface CursorNode extends BaseASTNode {
   type: 'CursorNode';
   context: CursorContext;
   position: number;
-  range: {
-    start: { line: number; character: number; offset: number };
-    end: { line: number; character: number; offset: number };
-  };
 }
 
 export interface CursorOperatorNode extends CursorNode {
@@ -22,6 +20,7 @@ export interface CursorOperatorNode extends CursorNode {
 
 export interface CursorIdentifierNode extends CursorNode {
   context: CursorContext.Identifier;
+  partialText?: string;
 }
 
 export interface CursorArgumentNode extends CursorNode {
@@ -37,6 +36,7 @@ export interface CursorIndexNode extends CursorNode {
 export interface CursorTypeNode extends CursorNode {
   context: CursorContext.Type;
   typeOperator: 'is' | 'as' | 'ofType';
+  partialText?: string;
 }
 
 export type AnyCursorNode = 
@@ -60,12 +60,13 @@ export function createCursorOperatorNode(position: number): CursorOperatorNode {
   };
 }
 
-export function createCursorIdentifierNode(position: number): CursorIdentifierNode {
+export function createCursorIdentifierNode(position: number, partialText?: string): CursorIdentifierNode {
   const point = { line: 0, character: position, offset: position };
   return {
     type: 'CursorNode',
     context: CursorContext.Identifier,
     position,
+    partialText,
     range: { start: point, end: point },
   };
 }
@@ -98,7 +99,8 @@ export function createCursorIndexNode(position: number): CursorIndexNode {
 
 export function createCursorTypeNode(
   position: number,
-  typeOperator: 'is' | 'as' | 'ofType'
+  typeOperator: 'is' | 'as' | 'ofType',
+  partialText?: string
 ): CursorTypeNode {
   const point = { line: 0, character: position, offset: position };
   return {
@@ -106,6 +108,7 @@ export function createCursorTypeNode(
     context: CursorContext.Type,
     position,
     typeOperator,
+    partialText,
     range: { start: point, end: point },
   };
 }