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

package/src/operations/matches-function.ts

@@ -0,0 +1,86 @@
+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('matches', input.length);
+  }
+
+  const boxedInputValue = input[0];
+  if (!boxedInputValue) {
+    return { value: [], context };
+  }
+  
+  const inputValue = unbox(boxedInputValue);
+  if (typeof inputValue !== 'string') {
+    throw Errors.stringOperationOnNonString('matches');
+  }
+
+  // Check arguments
+  if (args.length !== 1) {
+    throw Errors.wrongArgumentCount('matches', 1, args.length);
+  }
+
+  // Evaluate regex argument
+  const regexArg = args[0];
+  if (!regexArg) {
+    throw Errors.argumentRequired('matches', '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('matches 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('matches', 'regex argument');
+  }
+
+  try {
+    // Create regex with unicode support and single line mode (dotAll)
+    // Per spec: case-sensitive, single line mode, allow Unicode
+    const regex = new RegExp(regexPattern, 'us');
+    const result = regex.test(inputValue);
+    
+    return { value: [box(result, { type: 'Boolean', singleton: true })], context };
+  } catch (error) {
+    throw new Error(`Invalid regular expression in matches(): ${(error as Error).message}`);
+  }
+};
+
+export const matchesFunction: FunctionDefinition & { evaluate: FunctionEvaluator } = {
+  name: 'matches',
+  category: ['string'],
+  description: 'Returns true when the input string matches the given regular expression',
+  examples: [
+    "'test string'.matches('t.+')",
+    "'test string'.matches('asd.+')",
+    "'first line\\nsecond line'.matches('line.second')"
+  ],
+  signatures: [{
+    name: 'matches',
+    input: { type: 'String', singleton: true },
+    parameters: [
+      { name: 'regex', type: { type: 'String', singleton: true } }
+    ],
+    result: { type: 'Boolean', singleton: true }
+  }],
+  evaluate
+};

package/src/operations/matchesFull-function.ts

@@ -0,0 +1,96 @@
+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('matchesFull', input.length);
+  }
+
+  const boxedInputValue = input[0];
+  if (!boxedInputValue) {
+    return { value: [], context };
+  }
+  
+  const inputValue = unbox(boxedInputValue);
+  if (typeof inputValue !== 'string') {
+    throw Errors.stringOperationOnNonString('matchesFull');
+  }
+
+  // Check arguments
+  if (args.length !== 1) {
+    throw Errors.wrongArgumentCount('matchesFull', 1, args.length);
+  }
+
+  // Evaluate regex argument
+  const regexArg = args[0];
+  if (!regexArg) {
+    throw Errors.argumentRequired('matchesFull', '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('matchesFull 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('matchesFull', 'regex argument');
+  }
+
+  try {
+    // matchesFull implicitly adds ^ and $ anchors to match the entire string
+    // Only add anchors if they're not already present
+    let fullPattern = regexPattern;
+    if (!regexPattern.startsWith('^')) {
+      fullPattern = '^' + fullPattern;
+    }
+    if (!regexPattern.endsWith('$')) {
+      fullPattern = fullPattern + '$';
+    }
+    
+    // Create regex with unicode support and single line mode (dotAll)
+    // Per spec: case-sensitive, single line mode, allow Unicode
+    const regex = new RegExp(fullPattern, 'us');
+    const result = regex.test(inputValue);
+    
+    return { value: [box(result, { type: 'Boolean', singleton: true })], context };
+  } catch (error) {
+    throw new Error(`Invalid regular expression in matchesFull(): ${(error as Error).message}`);
+  }
+};
+
+export const matchesFullFunction: FunctionDefinition & { evaluate: FunctionEvaluator } = {
+  name: 'matchesFull',
+  category: ['string'],
+  description: 'Returns true when the input string completely matches the given regular expression',
+  examples: [
+    "'Library'.matchesFull('Library')",
+    "'http://example.org/Library'.matchesFull('Library')",
+    "'N8000123'.matchesFull('N[0-9]{7}')"
+  ],
+  signatures: [{
+    name: 'matchesFull',
+    input: { type: 'String', singleton: true },
+    parameters: [
+      { name: 'regex', type: { type: 'String', singleton: true } }
+    ],
+    result: { type: 'Boolean', singleton: true }
+  }],
+  evaluate
+};

package/src/operations/millisecondOf-function.ts

@@ -0,0 +1,66 @@
+// millisecondOf() function - Extracts millisecond 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 millisecondOfEvaluator: FunctionEvaluator = async (input, context, args) => {
+  // millisecondOf() takes no arguments
+  if (args.length !== 0) {
+    throw Errors.wrongArgumentCount('millisecondOf', 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('millisecondOf', 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 millisecond component is present
+    if (value.millisecond === undefined) {
+      return { value: [], context };
+    }
+    
+    // Return the millisecond as an Integer (0-999)
+    return {
+      value: [box(value.millisecond, { type: 'Integer', singleton: true })],
+      context
+    };
+  }
+  
+  // Not a Time or DateTime, return empty
+  return { value: [], context };
+};
+
+export const millisecondOfFunction: FunctionDefinition & { evaluate: typeof millisecondOfEvaluator } = {
+  name: 'millisecondOf',
+  category: ['temporal'],
+  description: 'Returns the millisecond component of a Time or DateTime value (0-999)',
+  examples: [
+    '@T10:30:45.123.millisecondOf()',
+    '@2014-01-05T10:30:45.500.millisecondOf()',
+    'Observation.effectiveDateTime.millisecondOf()'
+  ],
+  signatures: [
+    {
+      name: 'millisecondOf',
+      input: { type: 'Any', singleton: true },
+      parameters: [],
+      result: { type: 'Integer', singleton: true }
+    }
+  ],
+  evaluate: millisecondOfEvaluator
+};

package/src/operations/minus-operator.ts

@@ -1,9 +1,10 @@
 import type { OperatorDefinition } from '../types';
 import { PRECEDENCE } from '../types';
 import type { OperationEvaluator } from '../types';
-import { subtractQuantities } from '../quantity-value';
-import type { QuantityValue } from '../quantity-value';
-import { box, unbox } from '../boxing';
+import { subtractQuantities } from '../complex-types/quantity-value';
+import type { QuantityValue } from '../complex-types/quantity-value';
+import { box, unbox } from '../interpreter/boxing';
+import { normalizeDecimalResult } from '../utils/decimal';
 
 export const evaluate: OperationEvaluator = async (input, context, left, right) => {
   if (left.length === 0 || right.length === 0) {
@@ -17,6 +18,67 @@ export const evaluate: OperationEvaluator = async (input, context, left, right)
   if (!boxedr) return { value: [], context };
   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 quantity = r as QuantityValue;
+    
+    // Import temporal utilities and create TimeQuantity
+    const { createTimeQuantity, subtract } = 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 subtracted from 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 subtract operation
+    const result = subtract(l 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') {
+      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) {
@@ -26,7 +88,17 @@ export const evaluate: OperationEvaluator = async (input, context, left, right)
   
   // Handle numeric subtraction
   if (typeof l === 'number' && typeof r === 'number') {
-    return { value: [box(l - r, { type: 'Any', singleton: true })], context };
+    let result = l - r;
+    
+    // Normalize decimal result to handle floating point precision issues
+    if (!Number.isInteger(l) || !Number.isInteger(r)) {
+      result = normalizeDecimalResult(result, l, r);
+    }
+    
+    const typeInfo = Number.isInteger(result) ? 
+      { type: 'Integer' as const, singleton: true } : 
+      { type: 'Decimal' as const, singleton: true };
+    return { value: [box(result, typeInfo)], context };
   }
   
   // For other types, return empty

package/src/operations/minuteOf-function.ts

@@ -0,0 +1,66 @@
+// minuteOf() function - Extracts minute 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 minuteOfEvaluator: FunctionEvaluator = async (input, context, args) => {
+  // minuteOf() takes no arguments
+  if (args.length !== 0) {
+    throw Errors.wrongArgumentCount('minuteOf', 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('minuteOf', 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 minute component is present
+    if (value.minute === undefined) {
+      return { value: [], context };
+    }
+    
+    // Return the minute as an Integer (0-59)
+    return {
+      value: [box(value.minute, { type: 'Integer', singleton: true })],
+      context
+    };
+  }
+  
+  // Not a Time or DateTime, return empty
+  return { value: [], context };
+};
+
+export const minuteOfFunction: FunctionDefinition & { evaluate: typeof minuteOfEvaluator } = {
+  name: 'minuteOf',
+  category: ['temporal'],
+  description: 'Returns the minute component of a Time or DateTime value (0-59)',
+  examples: [
+    '@T10:30:00.minuteOf()',
+    '@2014-01-05T10:30:00.minuteOf()',
+    'Observation.effectiveDateTime.minuteOf()'
+  ],
+  signatures: [
+    {
+      name: 'minuteOf',
+      input: { type: 'Any', singleton: true },
+      parameters: [],
+      result: { type: 'Integer', singleton: true }
+    }
+  ],
+  evaluate: minuteOfEvaluator
+};

package/src/operations/mod-operator.ts

@@ -1,7 +1,8 @@
 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 { normalizeModuloResult } from '../utils/decimal';
 
 export const evaluate: OperationEvaluator = async (input, context, left, right) => {
   if (left.length === 0 || right.length === 0) {
@@ -21,7 +22,12 @@ export const evaluate: OperationEvaluator = async (input, context, left, right)
     return { value: [], context };
   }
   
-  const result = (leftValue as any) % (rightValue as any);
+  let result = (leftValue as any) % (rightValue as any);
+  
+  // Normalize decimal result to handle floating point precision issues
+  if (!Number.isInteger(leftValue) || !Number.isInteger(rightValue)) {
+    result = normalizeModuloResult(result, leftValue as number, rightValue as number);
+  }
   
   // Determine result type based on input types
   const resultType = Number.isInteger(leftValue) && Number.isInteger(rightValue) ? 'Integer' : 'Decimal';

package/src/operations/monthOf-function.ts

@@ -0,0 +1,66 @@
+// monthOf() function - Extracts month 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 monthOfEvaluator: FunctionEvaluator = async (input, context, args) => {
+  // monthOf() takes no arguments
+  if (args.length !== 0) {
+    throw Errors.wrongArgumentCount('monthOf', 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('monthOf', 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 month component is present
+    if (value.month === undefined) {
+      return { value: [], context };
+    }
+    
+    // Return the month as an Integer (1-12)
+    return {
+      value: [box(value.month, { type: 'Integer', singleton: true })],
+      context
+    };
+  }
+  
+  // Not a Date or DateTime, return empty
+  return { value: [], context };
+};
+
+export const monthOfFunction: FunctionDefinition & { evaluate: typeof monthOfEvaluator } = {
+  name: 'monthOf',
+  category: ['temporal'],
+  description: 'Returns the month component of a Date or DateTime value (1-12)',
+  examples: [
+    '@2014-01-05.monthOf()',
+    '@2014-01-05T10:30:00.monthOf()',
+    'Patient.birthDate.monthOf()'
+  ],
+  signatures: [
+    {
+      name: 'monthOf',
+      input: { type: 'Any', singleton: true },
+      parameters: [],
+      result: { type: 'Integer', singleton: true }
+    }
+  ],
+  evaluate: monthOfEvaluator
+};

package/src/operations/multiply-operator.ts

@@ -1,9 +1,9 @@
 import type { OperatorDefinition } from '../types';
 import { PRECEDENCE } from '../types';
 import type { OperationEvaluator } from '../types';
-import { multiplyQuantities } from '../quantity-value';
-import type { QuantityValue } from '../quantity-value';
-import { box, unbox } from '../boxing';
+import { multiplyQuantities } 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) {
@@ -71,6 +71,30 @@ export const multiplyOperator: OperatorDefinition & { evaluate: OperationEvaluat
       left: { type: 'Quantity', singleton: true },
       right: { type: 'Quantity', singleton: true },
       result: { type: 'Quantity', singleton: true },
+    },
+    {
+      name: 'quantity-integer-multiply',
+      left: { type: 'Quantity', singleton: true },
+      right: { type: 'Integer', singleton: true },
+      result: { type: 'Quantity', singleton: true },
+    },
+    {
+      name: 'integer-quantity-multiply',
+      left: { type: 'Integer', singleton: true },
+      right: { type: 'Quantity', singleton: true },
+      result: { type: 'Quantity', singleton: true },
+    },
+    {
+      name: 'quantity-decimal-multiply',
+      left: { type: 'Quantity', singleton: true },
+      right: { type: 'Decimal', singleton: true },
+      result: { type: 'Quantity', singleton: true },
+    },
+    {
+      name: 'decimal-quantity-multiply',
+      left: { type: 'Decimal', singleton: true },
+      right: { type: 'Quantity', singleton: true },
+      result: { type: 'Quantity', singleton: true },
     }
   ],
   evaluate

package/src/operations/not-equal-operator.ts

@@ -1,33 +1,19 @@
-import type { OperatorDefinition } from '../types';
+import type { OperatorDefinition, OperationEvaluator } from '../types';
 import { PRECEDENCE } from '../types';
-import type { OperationEvaluator } from '../types';
-import { equalQuantities, compareQuantities, type QuantityValue } from '../quantity-value';
-import { box, unbox } from '../boxing';
+import { box } from '../interpreter/boxing';
+import { collectionsNotEqual } from './comparison';
 
 export const evaluate: OperationEvaluator = async (input, context, left, right) => {
-  if (left.length === 0 || right.length === 0) {
-    return { value: [], context };
-  }
-  
-  const boxedl = left[0];
-  if (!boxedl) return { value: [], context };
-  const l = unbox(boxedl);
-  const boxedr = right[0];
-  if (!boxedr) return { value: [], context };
-  const r = unbox(boxedr);
+  // Use the unified comparison system
+  const result = collectionsNotEqual(left, right);
   
-  // Check if both are quantities
-  if (l && typeof l === 'object' && 'unit' in l && 
-      r && typeof r === 'object' && 'unit' in r) {
-    const comparison = compareQuantities(l as QuantityValue, r as QuantityValue);
-    // If quantities are incomparable (different dimensions), return empty
-    if (comparison === null) {
-      return { value: [], context };
-    }
-    return { value: [box(comparison !== 0, { type: 'Boolean', singleton: true })], context };
+  // null means incomparable (returns empty)
+  if (result === null) {
+    return { value: [], context };
   }
   
-  return { value: [box(l !== r, { type: 'Boolean', singleton: true })], context };
+  // Return the boolean result
+  return { value: [box(result, { type: 'Boolean', singleton: true })], context };
 };
 
 export const notEqualOperator: OperatorDefinition & { evaluate: OperationEvaluator } = {
@@ -38,11 +24,19 @@ export const notEqualOperator: OperatorDefinition & { evaluate: OperationEvaluat
   associativity: 'left',
   description: 'The converse of the equals operator, returning true if equal returns false; false if equal returns true; and empty ({ }) if equal returns empty',
   examples: ['name != "John"', 'Patient.gender != "male"', '5 != 3'],
-  signatures: [{
-    name: 'not-equal',
-    left: { type: 'Any', singleton: true },
-    right: { type: 'Any', singleton: true },
-    result: { type: 'Boolean', singleton: true },
-  }],
+  signatures: [
+    {
+      name: 'not-equal',
+      left: { type: 'Any', singleton: true },
+      right: { type: 'Any', singleton: true },
+      result: { type: 'Boolean', singleton: true },
+    },
+    {
+      name: 'not-equal',
+      left: { type: 'Any', singleton: false },
+      right: { type: 'Any', singleton: false },
+      result: { type: 'Boolean', singleton: true },
+    }
+  ],
   evaluate
 };