@atomic-ehr/fhirpath 0.0.3 → 0.0.4

package/src/operations/trace-function.ts

@@ -2,11 +2,24 @@ import type { FunctionDefinition, FunctionEvaluator } from '../types';
 import { Errors } from '../errors';
 import { box, unbox } from '../interpreter/boxing';
 
+// Check if trace output should be suppressed (during tests or when explicitly disabled)
+const shouldTrace = () => {
+  // Suppress trace output during tests
+  if (process.env.NODE_ENV === 'test') return false;
+  // Allow explicit disabling via FHIRPATH_TRACE=false
+  if (process.env.FHIRPATH_TRACE === 'false') return false;
+  // Check if we're running under bun test
+  if (typeof Bun !== 'undefined' && process.argv.some(arg => arg.includes('bun:test'))) return false;
+  return true;
+};
+
 export const evaluate: FunctionEvaluator = async (input, context, args, evaluator) => {
   // trace() requires at least a name argument
   if (args.length === 0) {
     // If no name provided, use a default name
-    console.log('[FHIRPath trace] (unnamed):', JSON.stringify(input));
+    if (shouldTrace()) {
+      console.log('[FHIRPath trace] (unnamed):', JSON.stringify(input));
+    }
     return { value: input, context };
   }
   
@@ -38,10 +51,14 @@ export const evaluate: FunctionEvaluator = async (input, context, args, evaluato
   // If projection argument is provided, evaluate it and log the result
   if (args.length === 2 && args[1]) {
     const projectionResult = await evaluator(args[1], input, context);
-    console.log(`[FHIRPath trace] ${name}:`, JSON.stringify(projectionResult.value));
+    if (shouldTrace()) {
+      console.log(`[FHIRPath trace] ${name}:`, JSON.stringify(projectionResult.value));
+    }
   } else {
     // Otherwise log the input
-    console.log(`[FHIRPath trace] ${name}:`, JSON.stringify(input));
+    if (shouldTrace()) {
+      console.log(`[FHIRPath trace] ${name}:`, JSON.stringify(input));
+    }
   }
 
   // Always return the input unchanged

package/src/operations/unescape-function.ts

@@ -0,0 +1,119 @@
+import type { FunctionDefinition, FunctionEvaluator } from '../types';
+import { Errors } from '../errors';
+import { box, unbox } from '../interpreter/boxing';
+
+const htmlUnescapeMap: Record<string, string> = {
+  '&amp;': '&',
+  '&lt;': '<',
+  '&gt;': '>',
+  '&quot;': '"',
+  '&#39;': "'",
+  '&#x27;': "'",
+  '&#x2F;': '/',
+};
+
+function unescapeHtml(str: string): string {
+  return str.replace(/&(?:amp|lt|gt|quot|#39|#x27|#x2F);/g, (entity) => htmlUnescapeMap[entity] || entity);
+}
+
+function unescapeJson(str: string): string {
+  // Handle JSON escape sequences
+  return str.replace(/\\(.)/g, (match, char) => {
+    switch (char) {
+      case '"': return '"';
+      case '\\': return '\\';
+      case '/': return '/';
+      case 'b': return '\b';
+      case 'f': return '\f';
+      case 'n': return '\n';
+      case 'r': return '\r';
+      case 't': return '\t';
+      default: return match; // Unknown escape, leave as is
+    }
+  });
+}
+
+export const evaluate: FunctionEvaluator = async (input, context, args, evaluator) => {
+  // unescape() takes exactly one argument (target)
+  if (args.length !== 1) {
+    throw Errors.wrongArgumentCount('unescape', 1, args.length);
+  }
+
+  // If input is empty, return empty
+  if (input.length === 0) {
+    return { value: [], context };
+  }
+
+  // If input has multiple items, error
+  if (input.length > 1) {
+    throw Errors.singletonRequired('unescape', input.length);
+  }
+
+  const boxedValue = input[0];
+  if (!boxedValue) {
+    return { value: [], context };
+  }
+  
+  const value = unbox(boxedValue);
+
+  // Value must be a string
+  if (typeof value !== 'string') {
+    throw Errors.invalidOperandType('unescape', `${typeof value}`);
+  }
+
+  // Evaluate target
+  const targetResult = await evaluator(args[0]!, input, context);
+  if (targetResult.value.length === 0) {
+    return { value: [], context };
+  }
+  if (targetResult.value.length > 1) {
+    throw Errors.invalidOperation('unescape target must be a single value');
+  }
+
+  const boxedTarget = targetResult.value[0];
+  if (!boxedTarget) {
+    return { value: [], context };
+  }
+  
+  const target = unbox(boxedTarget);
+  if (typeof target !== 'string') {
+    throw Errors.invalidOperation('unescape target must be a string');
+  }
+
+  // Unescape based on target
+  let result: string;
+  switch (target.toLowerCase()) {
+    case 'html':
+      result = unescapeHtml(value);
+      break;
+    case 'json':
+      result = unescapeJson(value);
+      break;
+    default:
+      // Unknown target, return empty
+      return { value: [], context };
+  }
+
+  return { value: [box(result, { type: 'String', singleton: true })], context };
+};
+
+export const unescapeFunction: FunctionDefinition & { evaluate: FunctionEvaluator } = {
+  name: 'unescape',
+  category: ['string'],
+  description: 'Unescapes a string for a given target (html or json)',
+  examples: [
+    "'&quot;test&quot;'.unescape('html')",
+    "'\\\"test\\\"'.unescape('json')"
+  ],
+  signatures: [
+    {
+      name: 'unescape',
+      input: { type: 'String', singleton: true },
+      parameters: [
+        { name: 'target', type: { type: 'String', singleton: true }, optional: false }
+      ],
+      result: { type: 'String', singleton: true }
+    }
+  ],
+  evaluate
+};

package/src/operations/where-function.ts

@@ -28,7 +28,9 @@ export const evaluate: FunctionEvaluator = async (input, context, args, evaluato
       continue;
     }
 
-    // Evaluate condition with temporary context (passing boxed item)
+    // Evaluate condition with temporary context
+    // When evaluating the condition, standalone functions should use $this as their implicit receiver
+    // We pass [boxedItem] which becomes the implicit context for functions
     const condResult = await evaluator(condition, [boxedItem], tempContext);
     
     // Include item if condition is true (unbox the boolean result)

package/src/parser.ts

@@ -471,7 +471,10 @@ export class Parser {
         }
       }
       
-      return this.createLiteralNode(numberValue, 'number', token);
+      // Determine if this is an integer or decimal based on the original token text
+      // If the token contains a decimal point, it's a decimal even if the value is a whole number
+      const isDecimal = token.value.includes('.');
+      return this.createLiteralNode(numberValue, isDecimal ? 'decimal' : 'number', token);
     }
 
     if (token.type === TokenType.STRING) {
@@ -682,7 +685,14 @@ export class Parser {
   protected parseStringValue(raw: string): string {
     // Remove quotes and handle escape sequences
     const content = raw.slice(1, -1);
-    return content.replace(/\\(.)/g, (_, char) => {
+    
+    // Handle unicode escapes first (\uXXXX)
+    let result = content.replace(/\\u([0-9a-fA-F]{4})/g, (_, hex) => {
+      return String.fromCharCode(parseInt(hex, 16));
+    });
+    
+    // Then handle other escape sequences
+    result = result.replace(/\\(.)/g, (_, char) => {
       switch (char) {
         case 'n': return '\n';
         case 'r': return '\r';
@@ -696,6 +706,8 @@ export class Parser {
         default: return char;
       }
     });
+    
+    return result;
   }
   
   protected parseIdentifierValue(raw: string): string {

package/src/types.ts

@@ -1,3 +1,4 @@
+import type { FHIRPathValue } from './interpreter/boxing';
 import type { Token, TokenType } from './lexer';
 import type { AnyCursorNode } from './parser/cursor-nodes';
 
@@ -9,13 +10,13 @@ export enum PRECEDENCE {
   XOR = 30,
   AND = 40,
   IN_CONTAINS = 50,
+  AS_IS = 55,         // as, is (moved to lower precedence)
   EQUALITY = 60,      // =, !=, ~, !~
+  PIPE = 65,          // | (moved to lower precedence) 
   COMPARISON = 70,    // <, >, <=, >=
-  PIPE = 80,          // |
   ADDITIVE = 90,      // +, -
   MULTIPLICATIVE = 100, // *, /, div, mod
   UNARY = 110,        // unary +, -, not
-  AS_IS = 120,        // as, is
   POSTFIX = 130,      // []
   DOT = 140,          // . (highest)
 }
@@ -105,6 +106,7 @@ export interface FunctionSignature {
     typeReference?: boolean; // When true, this parameter expects a type name (e.g., ofType(Patient))
   }>;
   result: TypeInfo | 'inputType' | 'inputTypeSingleton' | 'parameterType';
+  variadic?: boolean; // When true, the function accepts variable number of arguments
 }
 
 export interface FunctionDefinition {
@@ -230,7 +232,7 @@ export interface IdentifierNode extends BaseASTNode {
 export interface LiteralNode extends BaseASTNode {
   type: NodeType.Literal;
   value: any;
-  valueType: 'string' | 'number' | 'boolean' | 'date' | 'time' | 'datetime' | 'null';
+  valueType: 'string' | 'number' | 'decimal' | 'boolean' | 'date' | 'time' | 'datetime' | 'null';
 }
 
 export interface TemporalLiteralNode extends BaseASTNode {
@@ -328,8 +330,8 @@ export interface RuntimeContext {
 }
 
 // Evaluation result - everything is a collection of boxed values
-export interface EvaluationResult {
-  value: import('./interpreter/boxing').FHIRPathValue[];
+export interface EvaluationResult<T = any> {
+  value: T[];
   context: RuntimeContext;
 }
 

package/src/utils/decimal.ts

@@ -0,0 +1,76 @@
+/**
+ * Utility functions for handling decimal precision in FHIRPath
+ */
+
+/**
+ * Get the number of decimal places in a number
+ */
+export function getDecimalPlaces(n: number): number {
+  if (Number.isInteger(n)) {
+    return 0;
+  }
+  
+  // Convert to string and count decimal places
+  // Use toFixed(10) then strip trailing zeros to get actual precision
+  const str = n.toFixed(10).replace(/0+$/, '').replace(/\.$/, '');
+  const decimalIndex = str.indexOf('.');
+  
+  if (decimalIndex === -1) {
+    return 0;
+  }
+  
+  return str.length - decimalIndex - 1;
+}
+
+/**
+ * Round a number to a specific number of decimal places
+ */
+export function roundToDecimalPlaces(n: number, places: number): number {
+  if (places < 0) {
+    throw new Error('Decimal places must be non-negative');
+  }
+  
+  const multiplier = Math.pow(10, places);
+  return Math.round(n * multiplier) / multiplier;
+}
+
+/**
+ * Normalize a decimal result based on the precision of the operands
+ * According to FHIRPath spec, arithmetic operations should preserve
+ * the appropriate precision based on the input values
+ */
+export function normalizeDecimalResult(result: number, leftOperand: number, rightOperand: number): number {
+  // If result is effectively an integer, return it as is
+  if (Number.isInteger(result)) {
+    return result;
+  }
+  
+  // Get the precision of both operands
+  const leftPlaces = getDecimalPlaces(leftOperand);
+  const rightPlaces = getDecimalPlaces(rightOperand);
+  
+  // For addition and subtraction, use the maximum precision
+  // For multiplication, sum the precisions
+  // For division and modulo, use a reasonable precision (8 decimal places max)
+  const maxPrecision = Math.max(leftPlaces, rightPlaces);
+  
+  // Round to the appropriate precision to eliminate floating point artifacts
+  return roundToDecimalPlaces(result, Math.min(maxPrecision, 8));
+}
+
+/**
+ * Normalize a decimal for modulo operation
+ * Modulo has special precision rules
+ */
+export function normalizeModuloResult(result: number, leftOperand: number, rightOperand: number): number {
+  // If result is effectively an integer, return it as is
+  if (Number.isInteger(result)) {
+    return result;
+  }
+  
+  // For modulo, use the precision of the divisor (right operand)
+  const rightPlaces = getDecimalPlaces(rightOperand);
+  
+  // Round to the appropriate precision
+  return roundToDecimalPlaces(result, Math.min(rightPlaces, 8));
+}