@atomic-ehr/fhirpath 0.0.2 → 0.0.3

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

package/src/operations/temporal-functions.ts

@@ -0,0 +1,555 @@
+// Built-in temporal functions for FHIRPath
+import type { FunctionDefinition } from '../types';
+import type { FunctionEvaluator } from '../types';
+import { box } from '../interpreter/boxing';
+import { createDate, createDateTime, createTime, isFHIRDate, isFHIRDateTime, isFHIRTime } from '../complex-types/temporal';
+
+// ============================================================================
+// now() function - Returns current DateTime
+// ============================================================================
+
+export const nowEvaluator: FunctionEvaluator = async (input, context, args) => {
+  // Always use cached value if available (set at expression evaluation start)
+  const CACHE_KEY = '__fhirpath_now_cache__';
+  
+  if (context.variables[CACHE_KEY]) {
+    return {
+      value: [context.variables[CACHE_KEY]],
+      context
+    };
+  }
+  
+  // Fallback: create new value if not cached (shouldn't happen in normal evaluation)
+  const now = new Date();
+  const dateTime = createDateTime(
+    now.getFullYear(),
+    now.getMonth() + 1,
+    now.getDate(),
+    now.getHours(),
+    now.getMinutes(),
+    now.getSeconds(),
+    now.getMilliseconds(),
+    -now.getTimezoneOffset() // Convert to minutes from UTC (JS gives minutes to subtract from UTC)
+  );
+  
+  return {
+    value: [box(dateTime, { type: 'DateTime', singleton: true })],
+    context
+  };
+};
+
+export const nowFunction: FunctionDefinition & { evaluate: typeof nowEvaluator } = {
+  name: 'now',
+  category: ['temporal'],
+  description: 'Returns the current date and time as a DateTime value',
+  examples: ['now()', 'Patient.birthDate < now()'],
+  signatures: [
+    {
+      name: 'now',
+      input: { type: 'Any', singleton: false },
+      parameters: [],
+      result: { type: 'DateTime', singleton: true }
+    }
+  ],
+  evaluate: nowEvaluator
+};
+
+// ============================================================================
+// today() function - Returns current Date
+// ============================================================================
+
+export const todayEvaluator: FunctionEvaluator = async (input, context, args) => {
+  // Always use cached value if available (set at expression evaluation start)
+  const CACHE_KEY = '__fhirpath_today_cache__';
+  
+  if (context.variables[CACHE_KEY]) {
+    return {
+      value: [context.variables[CACHE_KEY]],
+      context
+    };
+  }
+  
+  // Fallback: create new value if not cached (shouldn't happen in normal evaluation)
+  const today = new Date();
+  const date = createDate(
+    today.getFullYear(),
+    today.getMonth() + 1,
+    today.getDate()
+  );
+  
+  return {
+    value: [box(date, { type: 'Date', singleton: true })],
+    context
+  };
+};
+
+export const todayFunction: FunctionDefinition & { evaluate: typeof todayEvaluator } = {
+  name: 'today',
+  category: ['temporal'],
+  description: 'Returns the current date (no time component)',
+  examples: ['today()', 'Patient.birthDate < today()'],
+  signatures: [
+    {
+      name: 'today',
+      input: { type: 'Any', singleton: false },
+      parameters: [],
+      result: { type: 'Date', singleton: true }
+    }
+  ],
+  evaluate: todayEvaluator
+};
+
+// ============================================================================
+// timeOfDay() function - Returns current Time
+// ============================================================================
+
+export const timeOfDayEvaluator: FunctionEvaluator = async (input, context, args) => {
+  // Always use cached value if available (set at expression evaluation start)
+  const CACHE_KEY = '__fhirpath_timeOfDay_cache__';
+  
+  if (context.variables[CACHE_KEY]) {
+    return {
+      value: [context.variables[CACHE_KEY]],
+      context
+    };
+  }
+  
+  // Fallback: create new value if not cached (shouldn't happen in normal evaluation)
+  const now = new Date();
+  const time = createTime(
+    now.getHours(),
+    now.getMinutes(),
+    now.getSeconds(),
+    now.getMilliseconds()
+  );
+  
+  return {
+    value: [box(time, { type: 'Time', singleton: true })],
+    context
+  };
+};
+
+export const timeOfDayFunction: FunctionDefinition & { evaluate: typeof timeOfDayEvaluator } = {
+  name: 'timeOfDay',
+  category: ['temporal'],
+  description: 'Returns the current time of day',
+  examples: ['timeOfDay()', '@T09:00 < timeOfDay()'],
+  signatures: [
+    {
+      name: 'timeOfDay',
+      input: { type: 'Any', singleton: false },
+      parameters: [],
+      result: { type: 'Time', singleton: true }
+    }
+  ],
+  evaluate: timeOfDayEvaluator
+};
+
+// ============================================================================
+// toDate() function - Convert to Date
+// ============================================================================
+
+export const toDateEvaluator: FunctionEvaluator = async (input, context, args) => {
+  if (input.length === 0) {
+    return { value: [], context };
+  }
+  
+  const boxedItem = input[0];
+  if (!boxedItem) {
+    return { value: [], context };
+  }
+  
+  const item = boxedItem.value;
+  const typeInfo = boxedItem.typeInfo;
+  
+  // If it's already a Date, return as is
+  if (typeInfo?.type === 'Date') {
+    return { value: [boxedItem], context };
+  }
+  
+  // If it's a DateTime, extract the date portion
+  if (typeInfo?.type === 'DateTime' && item && typeof item === 'object') {
+    const dateTime = item as any;
+    const date = createDate(dateTime.year, dateTime.month, dateTime.day);
+    return {
+      value: [box(date, { type: 'Date', singleton: true })],
+      context
+    };
+  }
+  
+  // If it's a String, try to parse it
+  if (typeof item === 'string') {
+    try {
+      const { parseTemporalLiteral, isFHIRDate } = await import('../complex-types/temporal');
+      const temporal = parseTemporalLiteral('@' + item);
+      if (isFHIRDate(temporal)) {
+        return {
+          value: [box(temporal, { type: 'Date', singleton: true })],
+          context
+        };
+      }
+    } catch {
+      // Parsing failed, return empty
+    }
+  }
+  
+  // For any other type (including Boolean), return empty
+  // This allows expressions like ({}).empty().toDate() to return []
+  return { value: [], context };
+};
+
+export const toDateFunction: FunctionDefinition & { evaluate: typeof toDateEvaluator } = {
+  name: 'toDate',
+  category: ['conversion', 'temporal'],
+  description: 'Converts the input to a Date value',
+  examples: ["'2020-01-15'.toDate()", '@2020-01-15T10:30:00.toDate()'],
+  signatures: [
+    {
+      name: 'any-toDate',
+      parameters: [],
+      input: { type: 'Any', singleton: true },
+      result: { type: 'Date', singleton: true }
+    }
+  ],
+  evaluate: toDateEvaluator
+};
+
+// ============================================================================
+// toDateTime() function - Convert to DateTime
+// ============================================================================
+
+export const toDateTimeEvaluator: FunctionEvaluator = async (input, context, args) => {
+  if (input.length === 0) {
+    return { value: [], context };
+  }
+  
+  const boxedItem = input[0];
+  if (!boxedItem) {
+    return { value: [], context };
+  }
+  
+  const item = boxedItem.value;
+  const typeInfo = boxedItem.typeInfo;
+  
+  // If it's already a DateTime, return as is
+  if (typeInfo?.type === 'DateTime') {
+    return { value: [boxedItem], context };
+  }
+  
+  // If it's a Date, convert to DateTime with time as 00:00:00
+  if (typeInfo?.type === 'Date' && item && typeof item === 'object') {
+    const date = item as any;
+    const dateTime = createDateTime(
+      date.year,
+      date.month,
+      date.day,
+      0, 0, 0, 0
+    );
+    return {
+      value: [box(dateTime, { type: 'DateTime', singleton: true })],
+      context
+    };
+  }
+  
+  // If it's a String, try to parse it
+  if (typeof item === 'string') {
+    try {
+      const { parseTemporalLiteral, isFHIRDate, isFHIRDateTime } = await import('../complex-types/temporal');
+      const temporal = parseTemporalLiteral('@' + item);
+      if (isFHIRDateTime(temporal)) {
+        return {
+          value: [box(temporal, { type: 'DateTime', singleton: true })],
+          context
+        };
+      } else if (isFHIRDate(temporal)) {
+        // Convert Date to DateTime (with time as 00:00:00)
+        const dateTime = createDateTime(
+          temporal.year,
+          temporal.month,
+          temporal.day,
+          0, 0, 0, 0
+        );
+        return {
+          value: [box(dateTime, { type: 'DateTime', singleton: true })],
+          context
+        };
+      }
+    } catch {
+      // Parsing failed, return empty
+    }
+  }
+  
+  // For any other type (including Boolean), return empty
+  // This allows expressions like ({}).empty().toDateTime() to return []
+  return { value: [], context };
+};
+
+export const toDateTimeFunction: FunctionDefinition & { evaluate: typeof toDateTimeEvaluator } = {
+  name: 'toDateTime',
+  category: ['conversion', 'temporal'],
+  description: 'Converts the input to a DateTime value',
+  examples: ["'2020-01-15T10:30:00Z'.toDateTime()", '@2020-01-15.toDateTime()'],
+  signatures: [
+    {
+      name: 'any-toDateTime',
+      parameters: [],
+      input: { type: 'Any', singleton: true },
+      result: { type: 'DateTime', singleton: true }
+    }
+  ],
+  evaluate: toDateTimeEvaluator
+};
+
+// ============================================================================
+// toTime() function - Convert to Time
+// ============================================================================
+
+export const toTimeEvaluator: FunctionEvaluator = async (input, context, args) => {
+  if (input.length === 0) {
+    return { value: [], context };
+  }
+  
+  const boxedItem = input[0];
+  if (!boxedItem) {
+    return { value: [], context };
+  }
+  
+  const item = boxedItem.value;
+  const typeInfo = boxedItem.typeInfo;
+  
+  // If it's already a Time, return as is
+  if (typeInfo?.type === 'Time') {
+    return { value: [boxedItem], context };
+  }
+  
+  // If it's a DateTime, extract the time portion
+  if (typeInfo?.type === 'DateTime' && item && typeof item === 'object') {
+    const dateTime = item as any;
+    if (dateTime.hour !== undefined) {
+      const time = createTime(dateTime.hour, dateTime.minute, dateTime.second, dateTime.millisecond);
+      return {
+        value: [box(time, { type: 'Time', singleton: true })],
+        context
+      };
+    }
+  }
+  
+  // If it's a String, try to parse it
+  if (typeof item === 'string') {
+    try {
+      const { parseTemporalLiteral, isFHIRTime } = await import('../complex-types/temporal');
+      // For time strings, prepend T if not present
+      const timeString = item.startsWith('T') ? '@' + item : '@T' + item;
+      const temporal = parseTemporalLiteral(timeString);
+      if (isFHIRTime(temporal)) {
+        return {
+          value: [box(temporal, { type: 'Time', singleton: true })],
+          context
+        };
+      }
+    } catch {
+      // Parsing failed, return empty
+    }
+  }
+  
+  // For any other type (including Boolean), return empty
+  // This allows expressions like ({}).empty().toTime() to return []
+  return { value: [], context };
+};
+
+export const toTimeFunction: FunctionDefinition & { evaluate: typeof toTimeEvaluator } = {
+  name: 'toTime',
+  category: ['conversion', 'temporal'],
+  description: 'Converts the input to a Time value',
+  examples: ["'14:30:00'.toTime()", '@2020-01-15T10:30:00.toTime()'],
+  signatures: [
+    {
+      name: 'any-toTime',
+      parameters: [],
+      input: { type: 'Any', singleton: true },
+      result: { type: 'Time', singleton: true }
+    }
+  ],
+  evaluate: toTimeEvaluator
+};
+
+// ============================================================================
+// convertsToDate() function - Check if convertible to Date
+// ============================================================================
+
+export const convertsToDateEvaluator: FunctionEvaluator = async (input, context, args) => {
+  if (input.length === 0) {
+    return { value: [], context };
+  }
+  
+  const boxedItem = input[0];
+  if (!boxedItem) {
+    return { value: [box(false, { type: 'Boolean', singleton: true })], context };
+  }
+  
+  const item = boxedItem.value;
+  const typeInfo = boxedItem.typeInfo;
+  
+  // Already a Date
+  if (typeInfo?.type === 'Date') {
+    return { value: [box(true, { type: 'Boolean', singleton: true })], context };
+  }
+  
+  // DateTime can be converted
+  if (typeInfo?.type === 'DateTime') {
+    return { value: [box(true, { type: 'Boolean', singleton: true })], context };
+  }
+  
+  // Try to parse string
+  if (typeof item === 'string') {
+    try {
+      const { parseTemporalLiteral, isFHIRDate } = await import('../complex-types/temporal');
+      const temporal = parseTemporalLiteral('@' + item);
+      return {
+        value: [box(isFHIRDate(temporal), { type: 'Boolean', singleton: true })],
+        context
+      };
+    } catch {
+      return { value: [box(false, { type: 'Boolean', singleton: true })], context };
+    }
+  }
+  
+  return { value: [box(false, { type: 'Boolean', singleton: true })], context };
+};
+
+export const convertsToDateFunction: FunctionDefinition & { evaluate: typeof convertsToDateEvaluator } = {
+  name: 'convertsToDate',
+  category: ['conversion', 'temporal'],
+  description: 'Returns true if the input can be converted to a Date',
+  examples: ["'2020-01-15'.convertsToDate()", "'invalid'.convertsToDate()"],
+  signatures: [
+    {
+      name: 'convertsToDate',
+      parameters: [],
+      input: { type: 'Any', singleton: true },
+      result: { type: 'Boolean', singleton: true }
+    }
+  ],
+  evaluate: convertsToDateEvaluator
+};
+
+// ============================================================================
+// convertsToDateTime() function - Check if convertible to DateTime
+// ============================================================================
+
+export const convertsToDateTimeEvaluator: FunctionEvaluator = async (input, context, args) => {
+  if (input.length === 0) {
+    return { value: [], context };
+  }
+  
+  const boxedItem = input[0];
+  if (!boxedItem) {
+    return { value: [box(false, { type: 'Boolean', singleton: true })], context };
+  }
+  
+  const item = boxedItem.value;
+  const typeInfo = boxedItem.typeInfo;
+  
+  // Already a DateTime
+  if (typeInfo?.type === 'DateTime') {
+    return { value: [box(true, { type: 'Boolean', singleton: true })], context };
+  }
+  
+  // Date can be converted
+  if (typeInfo?.type === 'Date') {
+    return { value: [box(true, { type: 'Boolean', singleton: true })], context };
+  }
+  
+  // Try to parse string
+  if (typeof item === 'string') {
+    try {
+      const { parseTemporalLiteral, isFHIRDate, isFHIRDateTime } = await import('../complex-types/temporal');
+      const temporal = parseTemporalLiteral('@' + item);
+      return {
+        value: [box(isFHIRDateTime(temporal) || isFHIRDate(temporal), { type: 'Boolean', singleton: true })],
+        context
+      };
+    } catch {
+      return { value: [box(false, { type: 'Boolean', singleton: true })], context };
+    }
+  }
+  
+  return { value: [box(false, { type: 'Boolean', singleton: true })], context };
+};
+
+export const convertsToDateTimeFunction: FunctionDefinition & { evaluate: typeof convertsToDateTimeEvaluator } = {
+  name: 'convertsToDateTime',
+  category: ['conversion', 'temporal'],
+  description: 'Returns true if the input can be converted to a DateTime',
+  examples: ["'2020-01-15T10:30:00'.convertsToDateTime()", "'invalid'.convertsToDateTime()"],
+  signatures: [
+    {
+      name: 'convertsToDateTime',
+      parameters: [],
+      input: { type: 'Any', singleton: true },
+      result: { type: 'Boolean', singleton: true }
+    }
+  ],
+  evaluate: convertsToDateTimeEvaluator
+};
+
+// ============================================================================
+// convertsToTime() function - Check if convertible to Time
+// ============================================================================
+
+export const convertsToTimeEvaluator: FunctionEvaluator = async (input, context, args) => {
+  if (input.length === 0) {
+    return { value: [], context };
+  }
+  
+  const boxedItem = input[0];
+  if (!boxedItem) {
+    return { value: [box(false, { type: 'Boolean', singleton: true })], context };
+  }
+  
+  const item = boxedItem.value;
+  const typeInfo = boxedItem.typeInfo;
+  
+  // Already a Time
+  if (typeInfo?.type === 'Time') {
+    return { value: [box(true, { type: 'Boolean', singleton: true })], context };
+  }
+  
+  // DateTime can be converted if it has time components
+  if (typeInfo?.type === 'DateTime') {
+    return { value: [box(true, { type: 'Boolean', singleton: true })], context };
+  }
+  
+  // Try to parse string
+  if (typeof item === 'string') {
+    try {
+      const { parseTemporalLiteral, isFHIRTime } = await import('../complex-types/temporal');
+      const timeString = item.startsWith('T') ? '@' + item : '@T' + item;
+      const temporal = parseTemporalLiteral(timeString);
+      return {
+        value: [box(isFHIRTime(temporal), { type: 'Boolean', singleton: true })],
+        context
+      };
+    } catch {
+      return { value: [box(false, { type: 'Boolean', singleton: true })], context };
+    }
+  }
+  
+  return { value: [box(false, { type: 'Boolean', singleton: true })], context };
+};
+
+export const convertsToTimeFunction: FunctionDefinition & { evaluate: typeof convertsToTimeEvaluator } = {
+  name: 'convertsToTime',
+  category: ['conversion', 'temporal'],
+  description: 'Returns true if the input can be converted to a Time',
+  examples: ["'14:30:00'.convertsToTime()", "'invalid'.convertsToTime()"],
+  signatures: [
+    {
+      name: 'convertsToTime',
+      parameters: [],
+      input: { type: 'Any', singleton: true },
+      result: { type: 'Boolean', singleton: true }
+    }
+  ],
+  evaluate: convertsToTimeEvaluator
+};