@atomic-ehr/fhirpath 0.0.2 → 0.0.3-canary.2be66fb.20250905161900

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,125 @@
+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');
+  }
+
+  // FHIRPath spec: empty pattern should return the original string unchanged
+  if (regexPattern === '') {
+    return { value: [box(inputValue, { type: 'String', singleton: true })], context };
+  }
+
+  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

package/src/operations/sqrt-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) => {
   // sqrt() takes no arguments
@@ -43,12 +43,19 @@ export const sqrtFunction: FunctionDefinition & { evaluate: FunctionEvaluator }
     '81.sqrt()',
     '(-1).sqrt()'
   ],
-  signatures: [{
-
-    name: 'sqrt',
-    input: { type: 'Decimal', singleton: true },
-    parameters: [],
-    result: { type: 'Decimal', singleton: true }
-  }],
+  signatures: [
+    {
+      name: 'sqrt-integer',
+      input: { type: 'Integer', singleton: true },
+      parameters: [],
+      result: { type: 'Decimal', singleton: true }
+    },
+    {
+      name: 'sqrt-decimal',
+      input: { type: 'Decimal', singleton: true },
+      parameters: [],
+      result: { type: 'Decimal', singleton: true }
+    }
+  ],
   evaluate
 };

package/src/operations/startsWith-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) => {
   // startsWith() requires exactly 1 argument

package/src/operations/subsetOf-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) {
@@ -19,7 +19,10 @@ export const evaluate: FunctionEvaluator = async (input, context, args, evaluato
   }
   // Evaluate the argument with the root context ($this), not the current input
   // This allows expressions like Patient.name.given to work correctly
-  const rootInput = context.variables['$this'] || context.input;
+  // $this contains the original input to the FHIRPath expression
+  // context.input contains the original input passed to evaluate()
+  // We should use $this if available, otherwise fall back to context.input
+  const rootInput = context.variables?.['$this'] || context.input || [];
   const otherResult = await evaluator(argNode, rootInput, context);
   const other = otherResult.value;
 
@@ -52,6 +55,7 @@ export const evaluate: FunctionEvaluator = async (input, context, args, evaluato
 
 export const subsetOfFunction: FunctionDefinition & { evaluate: FunctionEvaluator } = {
   name: 'subsetOf',
+  doesNotPropagateEmpty: true,  // Returns true if input is empty
   category: ['existence'],
   description: 'Returns true if all items in the input collection are members of the collection passed as the other argument. Membership is determined using the equals (=) operation.',
   examples: [

package/src/operations/substring-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) => {
   // Check single item in input

package/src/operations/supersetOf-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) {
@@ -14,7 +14,10 @@ export const evaluate: FunctionEvaluator = async (input, context, args, evaluato
   }
   // Evaluate the argument with the root context ($this), not the current input
   // This allows expressions like Patient.name.given to work correctly
-  const rootInput = context.variables['$this'] || context.input;
+  // $this contains the original input to the FHIRPath expression
+  // context.input contains the original input passed to evaluate()
+  // We should use $this if available, otherwise fall back to context.input
+  const rootInput = context.variables?.['$this'] || context.input || [];
   const otherResult = await evaluator(argNode, rootInput, context);
   const other = otherResult.value;
 
@@ -52,6 +55,7 @@ export const evaluate: FunctionEvaluator = async (input, context, args, evaluato
 
 export const supersetOfFunction: FunctionDefinition & { evaluate: FunctionEvaluator } = {
   name: 'supersetOf',
+  doesNotPropagateEmpty: true,  // Returns false if input is empty (unless other is also empty)
   category: ['existence'],
   description: 'Returns true if all items in the collection passed as the other argument are members of the input collection. Membership is determined using the equals (=) operation.',
   examples: [

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

package/src/operations/take-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) => {
   // Validate arguments