@atomic-ehr/fhirpath 0.0.2 → 0.0.3

package/src/operations/or-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 implementation
@@ -30,6 +30,7 @@ export const evaluate: OperationEvaluator = async (input, context, left, right)
 export const orOperator: OperatorDefinition & { evaluate: OperationEvaluator } = {
   symbol: 'or',
   name: 'or',
+  doesNotPropagateEmpty: true,  // Three-valued logic: true or empty = true
   category: ['logical'],
   precedence: PRECEDENCE.OR,
   associativity: 'left',

package/src/operations/plus-operator.ts

@@ -1,9 +1,9 @@
 import type { OperatorDefinition } from '../types';
 import { PRECEDENCE } from '../types';
 import type { OperationEvaluator } from '../types';
-import { addQuantities } from '../quantity-value';
-import type { QuantityValue } from '../quantity-value';
-import { box, unbox } from '../boxing';
+import { addQuantities } from '../complex-types/quantity-value';
+import type { QuantityValue } from '../complex-types/quantity-value';
+import { box, unbox } from '../interpreter/boxing';
 
 export const evaluate: OperationEvaluator = async (input, context, left, right) => {
   if (left.length === 0 || right.length === 0) {
@@ -20,6 +20,69 @@ export const evaluate: OperationEvaluator = async (input, context, left, right)
   const l = unbox(boxedL);
   const r = unbox(boxedR);
   
+  // Check for temporal arithmetic using boxed type information
+  const leftType = boxedL?.typeInfo?.type;
+  const rightType = boxedR?.typeInfo?.type;
+  
+  if ((leftType === 'Date' || leftType === 'DateTime' || leftType === 'Time') && rightType === 'Quantity') {
+    // Left is temporal, right is quantity
+    const temporalType = leftType;
+    const temporal = l;
+    const quantity = r as QuantityValue;
+    
+    // Import temporal utilities and create TimeQuantity
+    const { createTimeQuantity, add } = await import('../complex-types/temporal');
+    
+    // Calendar duration units (allowed for temporal arithmetic)
+    const calendarUnits = ['year', 'years', 'month', 'months', 'week', 'weeks', 
+                          'day', 'days', 'hour', 'hours', 'minute', 'minutes', 
+                          'second', 'seconds', 'millisecond', 'milliseconds'];
+    
+    // Variable duration UCUM units (not allowed for temporal arithmetic - they have calendar-dependent durations)
+    const variableDurationUnits = ['a', 'mo'];
+    
+    // Fixed duration UCUM units (allowed - they map directly to calendar units)
+    const fixedDurationUnitMap: Record<string, string> = {
+      'd': 'day',
+      'wk': 'week', 
+      'h': 'hour',
+      'min': 'minute',
+      's': 'second',
+      'ms': 'millisecond'
+    };
+    
+    // Check if this is a variable duration unit (not allowed)
+    if (variableDurationUnits.includes(quantity.unit)) {
+      // Variable duration units like 'a' and 'mo' cannot be added to temporal values
+      // because they don't have fixed durations
+      const { Errors } = await import('../errors');
+      throw Errors.invalidTemporalUnit(temporalType, quantity.unit);
+    }
+    
+    // Map fixed duration UCUM units to calendar units
+    let mappedUnit = fixedDurationUnitMap[quantity.unit] || quantity.unit;
+    
+    // Check if this is a valid calendar duration unit (after mapping)
+    if (!calendarUnits.includes(mappedUnit)) {
+      // Non-time units with temporal values return empty per FHIRPath spec
+      return { value: [], context };
+    }
+    
+    const timeQuantity = createTimeQuantity(quantity.value, mappedUnit as any);
+    
+    // Use the functional add operation
+    const result = add(temporal as any, timeQuantity);
+    
+    if (temporalType === 'Date') {
+      return { value: [box(result, { type: 'Date', singleton: true })], context };
+    } else if (temporalType === 'DateTime') {
+      return { value: [box(result, { type: 'DateTime', singleton: true })], context };
+    } else if (temporalType === 'Time') {
+      // Let the error propagate - adding calendar units to Time should throw
+      return { value: [box(result, { type: 'Time', singleton: true })], context };
+    }
+  }
+  
   // Check if both are quantities
   if (l && typeof l === 'object' && 'unit' in l && 
       r && typeof r === 'object' && 'unit' in r) {
@@ -27,8 +90,9 @@ export const evaluate: OperationEvaluator = async (input, context, left, right)
     return { value: result ? [box(result, { type: 'Quantity', singleton: true })] : [], context };
   }
   
-  if (typeof l === 'string' || typeof r === 'string') {
-    return { value: [box(String(l) + String(r), { type: 'String', singleton: true })], context };
+  // String concatenation only works for string + string
+  if (typeof l === 'string' && typeof r === 'string') {
+    return { value: [box(l + r, { type: 'String', singleton: true })], context };
   }
   
   if (typeof l === 'number' && typeof r === 'number') {
@@ -39,8 +103,8 @@ export const evaluate: OperationEvaluator = async (input, context, left, right)
     return { value: [box(result, typeInfo)], context };
   }
   
-  // For other types, convert to string
-  return { value: [box(String(l) + String(r), { type: 'String', singleton: true })], context };
+  // For incompatible types, return empty per FHIRPath spec
+  return { value: [], context };
 };
 
 export const plusOperator: OperatorDefinition & { evaluate: OperationEvaluator } = {

package/src/operations/power-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) => {
   // power() takes exactly one argument (exponent)
@@ -75,14 +75,39 @@ export const powerFunction: FunctionDefinition & { evaluate: FunctionEvaluator }
     '2.5.power(2)',
     '(-1).power(0.5)'
   ],
-  signatures: [{
-
-    name: 'power',
-    input: { type: 'Decimal', singleton: true },
-    parameters: [
-      { name: 'exponent', type: { type: 'Decimal', singleton: true }, optional: false }
-    ],
-    result: { type: 'Decimal', singleton: true }
-  }],
+  signatures: [
+    {
+      name: 'power-integer',
+      input: { type: 'Integer', singleton: true },
+      parameters: [
+        { name: 'exponent', type: { type: 'Integer', singleton: true }, optional: false }
+      ],
+      result: { type: 'Integer', singleton: true }
+    },
+    {
+      name: 'power-decimal',
+      input: { type: 'Decimal', singleton: true },
+      parameters: [
+        { name: 'exponent', type: { type: 'Decimal', singleton: true }, optional: false }
+      ],
+      result: { type: 'Decimal', singleton: true }
+    },
+    {
+      name: 'power-integer-decimal',
+      input: { type: 'Integer', singleton: true },
+      parameters: [
+        { name: 'exponent', type: { type: 'Decimal', singleton: true }, optional: false }
+      ],
+      result: { type: 'Decimal', singleton: true }
+    },
+    {
+      name: 'power-decimal-integer',
+      input: { type: 'Decimal', singleton: true },
+      parameters: [
+        { name: 'exponent', type: { type: 'Integer', singleton: true }, optional: false }
+      ],
+      result: { type: 'Decimal', singleton: true }
+    }
+  ],
   evaluate
 };

package/src/operations/repeat-function.ts

@@ -0,0 +1,169 @@
+import type { FunctionDefinition, AnalysisContext, InternalAnalysisResult } from '../types';
+import { Errors } from '../errors';
+import { RuntimeContextManager } from '../interpreter/runtime-context';
+import { type FunctionEvaluator } from '../types';
+import { unbox, box } from '../interpreter/boxing';
+import { collectionsEqual } from './comparison';
+
+export const evaluate: FunctionEvaluator = async (input, context, args, evaluator) => {
+  // Repeat requires exactly one argument
+  if (args.length !== 1) {
+    throw Errors.wrongArgumentCount('repeat', 1, args.length);
+  }
+
+  const expression = args[0];
+  if (!expression) {
+    throw Errors.invalidOperation('repeat requires a projection expression');
+  }
+  
+  // Result collection that will accumulate all unique items
+  const result: any[] = [];
+  
+  // Track which items we've already seen to detect duplicates
+  const seen = new Set<any>();
+  
+  // Helper to check if an item is already in the result
+  const isInResult = (item: any): boolean => {
+    for (const existing of result) {
+      // Use equals comparison to determine if items are the same
+      const equalResult = collectionsEqual([existing], [item]);
+      if (equalResult === true) {
+        return true;
+      }
+    }
+    return false;
+  };
+  
+  // Initial evaluation on input collection
+  const initialResults: any[] = [];
+  for (let i = 0; i < input.length; i++) {
+    const boxedItem = input[i];
+    if (!boxedItem) continue;
+    
+    const item = unbox(boxedItem);
+    
+    // Create iterator context with $this and $index
+    let tempContext = RuntimeContextManager.withIterator(context, item, i);
+    tempContext = RuntimeContextManager.setVariable(tempContext, '$total', input.length);
+    
+    // Evaluate expression with temporary context
+    const exprResult = await evaluator(expression, [boxedItem], tempContext);
+    
+    // Add results from initial evaluation
+    for (const newItem of exprResult.value) {
+      if (newItem && !isInResult(newItem)) {
+        result.push(newItem);
+        initialResults.push(newItem);
+      }
+    }
+  }
+  
+  // Now process the queue with items from the initial results
+  let queue = [...initialResults];
+  
+  // Process items until queue is empty
+  while (queue.length > 0) {
+    const nextQueue: any[] = [];
+    
+    for (let i = 0; i < queue.length; i++) {
+      const boxedItem = queue[i];
+      if (!boxedItem) continue;
+      
+      const item = unbox(boxedItem);
+      
+      // Create iterator context with $this and $index
+      let tempContext = RuntimeContextManager.withIterator(context, item, i);
+      tempContext = RuntimeContextManager.setVariable(tempContext, '$total', queue.length);
+      
+      // Evaluate expression with temporary context
+      const exprResult = await evaluator(expression, [boxedItem], tempContext);
+      
+      // Add new items to the result and next queue
+      for (const newItem of exprResult.value) {
+        if (newItem && !isInResult(newItem)) {
+          result.push(newItem);
+          nextQueue.push(newItem);
+        }
+      }
+    }
+    
+    // Move to next iteration
+    queue = nextQueue;
+  }
+  
+  return { value: result, context };
+};
+
+export const repeatFunction: FunctionDefinition & { evaluate: FunctionEvaluator } = {
+  name: 'repeat',
+  category: ['collection'],
+  description: 'A version of select that will repeat the projection and add items to the output collection only if they are not already in the output collection as determined by the equals (=) operator. Can be used to traverse a tree by repeatedly selecting specific children.',
+  examples: [
+    'ValueSet.expansion.repeat(contains)',
+    'Questionnaire.repeat(item)',
+    'Bundle.entry.repeat(resource.link)'
+  ],
+  signatures: [{
+    name: 'repeat',
+    input: { type: 'Any', singleton: false },
+    parameters: [
+      { name: 'projection', type: { type: 'Any', singleton: false }, expression: true },
+    ],
+    result: 'parameterType' as any,
+  }],
+  evaluate,
+  
+  /**
+   * Analysis-time behavior for repeat.
+   * Similar to select, but with repeated application.
+   */
+  async analyze(context: AnalysisContext, args): Promise<InternalAnalysisResult> {
+    const diagnostics: any[] = [];
+    
+    if (args.length !== 1) {
+      return {
+        type: { type: 'Any', singleton: false },
+        diagnostics: [{
+          message: 'repeat expects exactly 1 argument',
+          severity: 'error' as any,
+          range: { start: { line: 0, character: 0 }, end: { line: 0, character: 0 } }
+        }]
+      };
+    }
+    
+    // Get element type from input
+    const elementType = context.inputType.singleton 
+      ? context.inputType 
+      : { ...context.inputType, singleton: true };
+    
+    // Create context for analyzing the projection
+    const projectionContext = context
+      .withInputType(elementType)
+      .withSystemVariable('$this', elementType)
+      .withSystemVariable('$index', { type: 'Integer', singleton: true })
+      .withSystemVariable('$total', { type: 'Integer', singleton: true });
+    
+    // Analyze the projection expression
+    const projectionArg = args[0];
+    if (!projectionArg) {
+      return {
+        type: { type: 'Any', singleton: false },
+        diagnostics,
+        context
+      };
+    }
+    const projectionResult = await projectionContext.analyzeNode(projectionArg);
+    diagnostics.push(...projectionResult.diagnostics);
+    
+    // Result type is the type returned by the projection (as a collection)
+    const resultType = projectionResult.type.singleton
+      ? { ...projectionResult.type, singleton: false }
+      : projectionResult.type;
+    
+    return {
+      type: resultType,
+      diagnostics,
+      context
+    };
+  }
+};

package/src/operations/replace-function.ts

@@ -1,7 +1,7 @@
 import type { FunctionDefinition } from '../types';
 import { Errors } from '../errors';
 import type { FunctionEvaluator } from '../types';
-import { box, unbox } from '../boxing';
+import { box, unbox } from '../interpreter/boxing';
 
 export const evaluate: FunctionEvaluator = async (input, context, args, evaluator) => {
   // Check if we have exactly 2 arguments

package/src/operations/replaceMatches-function.ts

@@ -0,0 +1,120 @@
+import type { FunctionDefinition, FunctionEvaluator } from '../types';
+import { Errors } from '../errors';
+import { box, unbox } from '../interpreter/boxing';
+
+export const evaluate: FunctionEvaluator = async (input, context, args, evaluator) => {
+  // Check single item in input
+  if (input.length === 0) {
+    return { value: [], context };
+  }
+  
+  if (input.length > 1) {
+    throw Errors.stringSingletonRequired('replaceMatches', input.length);
+  }
+
+  const boxedInputValue = input[0];
+  if (!boxedInputValue) {
+    return { value: [], context };
+  }
+  
+  const inputValue = unbox(boxedInputValue);
+  if (typeof inputValue !== 'string') {
+    throw Errors.stringOperationOnNonString('replaceMatches');
+  }
+
+  // Check arguments
+  if (args.length !== 2) {
+    throw Errors.wrongArgumentCount('replaceMatches', 2, args.length);
+  }
+
+  // Evaluate regex argument
+  const regexArg = args[0];
+  if (!regexArg) {
+    throw Errors.argumentRequired('replaceMatches', 'regex argument');
+  }
+  
+  const regexResult = await evaluator(regexArg, input, context);
+  
+  if (regexResult.value.length === 0) {
+    return { value: [], context };
+  }
+  
+  if (regexResult.value.length > 1) {
+    throw Errors.singletonRequired('replaceMatches regex', regexResult.value.length);
+  }
+  
+  const boxedRegex = regexResult.value[0];
+  if (!boxedRegex) {
+    return { value: [], context };
+  }
+  
+  const regexPattern = unbox(boxedRegex);
+  if (typeof regexPattern !== 'string') {
+    throw Errors.invalidStringOperation('replaceMatches', 'regex argument');
+  }
+
+  // Evaluate substitution argument
+  const substitutionArg = args[1];
+  if (!substitutionArg) {
+    throw Errors.argumentRequired('replaceMatches', 'substitution argument');
+  }
+  
+  const substitutionResult = await evaluator(substitutionArg, input, context);
+  
+  if (substitutionResult.value.length === 0) {
+    return { value: [], context };
+  }
+  
+  if (substitutionResult.value.length > 1) {
+    throw Errors.singletonRequired('replaceMatches substitution', substitutionResult.value.length);
+  }
+  
+  const boxedSubstitution = substitutionResult.value[0];
+  if (!boxedSubstitution) {
+    return { value: [], context };
+  }
+  
+  const substitution = unbox(boxedSubstitution);
+  if (typeof substitution !== 'string') {
+    throw Errors.invalidStringOperation('replaceMatches', 'substitution argument');
+  }
+
+  try {
+    // Create regex with unicode support, single line mode (dotAll), and global flag for all matches
+    // Per spec: case-sensitive, single line mode, allow Unicode
+    const regex = new RegExp(regexPattern, 'gus');
+    
+    // JavaScript's replace supports $1, $2 etc for capture groups
+    // The spec also mentions named groups with ${name} syntax
+    // JavaScript natively supports both $1 and $<name> syntax
+    // We need to convert ${name} to $<name> for JavaScript compatibility
+    const jsSubstitution = substitution.replace(/\$\{([^}]+)\}/g, '$<$1>');
+    
+    const result = inputValue.replace(regex, jsSubstitution);
+    
+    return { value: [box(result, { type: 'String', singleton: true })], context };
+  } catch (error) {
+    throw new Error(`Invalid regular expression in replaceMatches(): ${(error as Error).message}`);
+  }
+};
+
+export const replaceMatchesFunction: FunctionDefinition & { evaluate: FunctionEvaluator } = {
+  name: 'replaceMatches',
+  category: ['string'],
+  description: 'Replaces all matches of the regex pattern with the substitution string',
+  examples: [
+    "'test string'.replaceMatches('test', 'match')",
+    "'11/30/1972'.replaceMatches('\\\\b(\\\\d{1,2})/(\\\\d{1,2})/(\\\\d{2,4})\\\\b', '$2-$1-$3')",
+    "'test test'.replaceMatches('t', 'T')"
+  ],
+  signatures: [{
+    name: 'replaceMatches',
+    input: { type: 'String', singleton: true },
+    parameters: [
+      { name: 'regex', type: { type: 'String', singleton: true } },
+      { name: 'substitution', type: { type: 'String', singleton: true } }
+    ],
+    result: { type: 'String', singleton: true }
+  }],
+  evaluate
+};

package/src/operations/round-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) => {
   // round() takes 0 or 1 argument (precision)

package/src/operations/secondOf-function.ts

@@ -0,0 +1,66 @@
+// secondOf() function - Extracts second component from Time or DateTime
+import type { FunctionDefinition, FunctionEvaluator } from '../types';
+import { box, unbox } from '../interpreter/boxing';
+import { isFHIRTime, isFHIRDateTime } from '../complex-types/temporal';
+import { Errors } from '../errors';
+
+export const secondOfEvaluator: FunctionEvaluator = async (input, context, args) => {
+  // secondOf() takes no arguments
+  if (args.length !== 0) {
+    throw Errors.wrongArgumentCount('secondOf', 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('secondOf', input.length);
+  }
+  
+  const boxedValue = input[0];
+  if (!boxedValue) {
+    return { value: [], context };
+  }
+  
+  const value = unbox(boxedValue);
+  
+  // Check if it's a Time or DateTime
+  if (isFHIRTime(value) || isFHIRDateTime(value)) {
+    // Check if second component is present
+    if (value.second === undefined) {
+      return { value: [], context };
+    }
+    
+    // Return the second as an Integer (0-59)
+    return {
+      value: [box(value.second, { type: 'Integer', singleton: true })],
+      context
+    };
+  }
+  
+  // Not a Time or DateTime, return empty
+  return { value: [], context };
+};
+
+export const secondOfFunction: FunctionDefinition & { evaluate: typeof secondOfEvaluator } = {
+  name: 'secondOf',
+  category: ['temporal'],
+  description: 'Returns the second component of a Time or DateTime value (0-59)',
+  examples: [
+    '@T10:30:45.secondOf()',
+    '@2014-01-05T10:30:45.secondOf()',
+    'Observation.effectiveDateTime.secondOf()'
+  ],
+  signatures: [
+    {
+      name: 'secondOf',
+      input: { type: 'Any', singleton: true },
+      parameters: [],
+      result: { type: 'Integer', singleton: true }
+    }
+  ],
+  evaluate: secondOfEvaluator
+};

package/src/operations/select-function.ts

@@ -1,8 +1,8 @@
-import type { FunctionDefinition } from '../types';
+import type { FunctionDefinition, AnalysisContext, InternalAnalysisResult } from '../types';
 import { Errors } from '../errors';
-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) => {
   // Select requires exactly one argument
@@ -55,5 +55,66 @@ export const selectFunction: FunctionDefinition & { evaluate: FunctionEvaluator
     ],
     result: 'parameterType' as any,
   }],
-  evaluate
-};
+  evaluate,
+  
+  /**
+   * Analysis-time behavior for select.
+   * The projection expression needs to be analyzed with system variables in scope.
+   */
+  async analyze(context: AnalysisContext, args): Promise<InternalAnalysisResult> {
+    const diagnostics: any[] = [];
+    
+    if (args.length !== 1) {
+      return {
+        type: { type: 'Any', singleton: false },
+        diagnostics: [{
+          message: 'select expects exactly 1 argument',
+          severity: 'error' as any,
+          range: { start: { line: 0, character: 0 }, end: { line: 0, character: 0 } }
+        }]
+      };
+    }
+    
+    // For select, we need to analyze the projection expression with:
+    // 1. $this set to each element type
+    // 2. $index available as Integer
+    // 3. User variables from the outer context preserved
+    
+    // Get element type from input
+    const elementType = context.inputType.singleton 
+      ? context.inputType 
+      : { ...context.inputType, singleton: true };
+    
+    // Create context for analyzing the projection
+    // Add system variables but preserve user variables
+    // IMPORTANT: Also update input type to the element type for property navigation
+    const projectionContext = context
+      .withInputType(elementType)
+      .withSystemVariable('$this', elementType)
+      .withSystemVariable('$index', { type: 'Integer', singleton: true })
+      .withSystemVariable('$total', { type: 'Integer', singleton: true });
+    
+    // Analyze the projection expression
+    const projectionArg = args[0];
+    if (!projectionArg) {
+      return {
+        type: { type: 'Any', singleton: false },
+        diagnostics,
+        context
+      };
+    }
+    const projectionResult = await projectionContext.analyzeNode(projectionArg);
+    diagnostics.push(...projectionResult.diagnostics);
+    
+    // Result type is the type returned by the projection (as a collection)
+    const resultType = projectionResult.type.singleton
+      ? { ...projectionResult.type, singleton: false }
+      : projectionResult.type;
+    
+    return {
+      type: resultType,
+      diagnostics,
+      context // Return original context - select doesn't modify outer scope
+    };
+  }
+};

package/src/operations/single-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) => {
   // single takes no arguments

package/src/operations/skip-function.ts

@@ -1,7 +1,7 @@
 import type { FunctionDefinition } from '../types';
 import { Errors } from '../errors';
 import type { FunctionEvaluator } from '../types';
-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/split-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