@aehrc/smart-forms-renderer 1.0.0-alpha.99 → 1.1.0

package/src/utils/columnWidth.test.ts

@@ -0,0 +1,75 @@
+/*
+ * Copyright 2025 Commonwealth Scientific and Industrial Research
+ * Organisation (CSIRO) ABN 41 687 119 230.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { calculateColumnWidths } from './columnWidth';
+
+describe('calculateColumnWidths', () => {
+  it('all columns as percentages', () => {
+    const columnWidths = ['25%', '25%', '25%', '25%'];
+    const result = calculateColumnWidths(columnWidths, 1000);
+    expect(result.map((r) => r.width)).toEqual(['25%', '25%', '25%', '25%']);
+  });
+
+  it('one column as px, rest unset', () => {
+    const columnWidths = [undefined, '400px', undefined];
+    const result = calculateColumnWidths(columnWidths, 1000);
+    // 1000 - 400 = 600, split between 2 unset columns
+    expect(result[0].width).toBe('300px');
+    expect(result[1].width).toBe('400px');
+    expect(result[2].width).toBe('300px');
+  });
+
+  it('one column as %, rest unset', () => {
+    const columnWidths = [undefined, '70%', undefined];
+    const result = calculateColumnWidths(columnWidths, 1000);
+    // 70% = 700px, 300px left for 2 columns
+    expect(result[0].width).toBe('150px');
+    expect(result[1].width).toBe('70%');
+    expect(result[2].width).toBe('150px');
+  });
+
+  it('mixed px and % columns', () => {
+    const columnWidths = [undefined, '400px', '20%', undefined];
+    const result = calculateColumnWidths(columnWidths, 1200);
+    // 400px + 20% of 1200 = 400px + 240px = 640px, 560px left for 2 unset
+    expect(result[0].width).toBe('280px');
+    expect(result[1].width).toBe('400px');
+    expect(result[2].width).toBe('20%');
+    expect(result[3].width).toBe('280px');
+  });
+
+  it('all columns px, sum < table width', () => {
+    const columnWidths = ['200px', '300px'];
+    const result = calculateColumnWidths(columnWidths, 700);
+    expect(result[0].width).toBe('200px');
+    expect(result[1].width).toBe('300px');
+  });
+
+  it('all columns px, sum > table width (overflow)', () => {
+    const columnWidths = ['500px', '600px'];
+    const result = calculateColumnWidths(columnWidths, 1000);
+    expect(result[0].width).toBe('500px');
+    expect(result[1].width).toBe('600px');
+  });
+
+  it('handles empty columns', () => {
+    const columnWidths = [undefined, undefined];
+    const result = calculateColumnWidths(columnWidths, 1000);
+    expect(result[0].width).toBe('500px');
+    expect(result[1].width).toBe('500px');
+  });
+});

package/src/utils/columnWidth.ts

@@ -0,0 +1,110 @@
+/*
+ * Copyright 2025 Commonwealth Scientific and Industrial Research
+ * Organisation (CSIRO) ABN 41 687 119 230.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Calculates the final widths for each column given the column widths and table width.
+ * @param columnWidthsSDC Array of column widths from http://hl7.org/fhir/uv/sdc/StructureDefinition-sdc-questionnaire-width.html (string or undefined)
+ * @param tableWidth Table width in px
+ * @returns Array of calculated column widths (in px or %)
+ *
+ * @example
+ * columnWidthsSDC: [undefined, "400px", undefined]
+ * tableWidth: 1200 (Comes from tableContainerRef.current.offsetWidth)
+ * output: [
+ *   {
+ *     "width": "325px",
+ *     "isFixed": true
+ *   },
+ *   {
+ *     "width": "550px",
+ *     "isFixed": true
+ *   },
+ *   {
+ *     "width": "325px",
+ *     "isFixed": true
+ *   }
+ * ]
+ */
+export function calculateColumnWidths(
+  columnWidthsSDC: (string | undefined)[],
+  tableWidth: number
+): { width: string; isFixed: boolean }[] {
+  // Parse columns into px, %, and unset
+  const pxColumns: { idx: number; px: number }[] = [];
+  const percentColumns: { idx: number; percent: number }[] = [];
+  const unsetColumns: { idx: number }[] = [];
+
+  columnWidthsSDC.forEach((col, idx) => {
+    if (col?.endsWith('px')) {
+      const px = parseInt(col);
+      pxColumns.push({ idx, px });
+    } else if (col?.endsWith('%')) {
+      const percent = parseFloat(col);
+      percentColumns.push({ idx, percent });
+    } else {
+      unsetColumns.push({ idx });
+    }
+  });
+
+  // Calculate total px and %
+  const totalPx = pxColumns.reduce((sum, c) => sum + c.px, 0);
+
+  // Calculate px for % columns
+  const percentPx = percentColumns.map((c) => ({
+    ...c,
+    px: (c.percent / 100) * tableWidth
+  }));
+  const totalPercentPx = percentPx.reduce((sum, c) => sum + c.px, 0);
+
+  // Remaining px for unset columns
+  let remainingPx = tableWidth - totalPx - totalPercentPx;
+  if (remainingPx < 0) remainingPx = 0; // overflow, will be handled by scroll
+
+  // Distribute remaining px equally to unset columns
+  const unsetPx = unsetColumns.length > 0 ? remainingPx / unsetColumns.length : 0;
+
+  // Build result array
+  return columnWidthsSDC.map((col, idx) => {
+    // px columns
+    const pxCol = pxColumns.find((c) => c.idx === idx);
+    if (pxCol) {
+      return {
+        width: `${pxCol.px}px`,
+        isFixed: true
+      };
+    }
+    // % columns
+    const percentCol = percentColumns.find((c) => c.idx === idx);
+    if (percentCol) {
+      return {
+        width: `${percentCol.percent}%`,
+        isFixed: false
+      };
+    }
+    // unset columns
+    const unsetCol = unsetColumns.find((c) => c.idx === idx);
+    if (unsetCol) {
+      return {
+        width: `${unsetPx}px`,
+        isFixed: true
+      };
+    }
+
+    // fallback
+    return { width: 'auto', isFixed: false };
+  });
+}

package/src/utils/enableWhenExpression.ts

@@ -16,7 +16,12 @@
  */
 
 import type { QuestionnaireResponse, QuestionnaireResponseItem } from 'fhir/r4';
-import { createFhirPathContext, handleFhirPathResult } from './fhirpath';
+import {
+  cacheTerminologyResult,
+  createFhirPathContext,
+  handleFhirPathResult,
+  isExpressionCached
+} from './fhirpath';
 import fhirpath from 'fhirpath';
 import fhirpath_r4_model from 'fhirpath/fhir-context/r4';
 import type {
@@ -104,8 +109,7 @@ async function evaluateEnableWhenSingleExpressions(
     const initialValue = enableWhenSingleExpressions[linkId].isEnabled;
     const expression = enableWhenSingleExpressions[linkId].expression;
 
-    const cacheKey = JSON.stringify(expression); // Use expression as cache key
-    if (fhirPathTerminologyCache[cacheKey]) {
+    if (isExpressionCached(expression, fhirPathTerminologyCache)) {
       continue;
     }
 
@@ -124,7 +128,7 @@ async function evaluateEnableWhenSingleExpressions(
 
       // If fhirPathResult is an async terminology call, cache the result
       if (fhirPathResult instanceof Promise) {
-        fhirPathTerminologyCache[cacheKey] = result;
+        cacheTerminologyResult(expression, result, fhirPathTerminologyCache);
       }
 
       // Update enableWhenExpressions if length of result array > 0
@@ -291,7 +295,7 @@ export async function evaluateEnableWhenExpressions(
   enableWhenExpressions: EnableWhenExpressions,
   terminologyServerUrl: string
 ): Promise<{
-  enableWhenExpsIsUpdated: boolean;
+  isUpdated: boolean;
   updatedEnableWhenExpressions: EnableWhenExpressions;
 }> {
   const updatedEnableWhenExpressions: EnableWhenExpressions = {
@@ -315,7 +319,7 @@ export async function evaluateEnableWhenExpressions(
     updatedEnableWhenSingleExpressions.isUpdated || updatedEnableWhenRepeatExpressions.isUpdated;
 
   return {
-    enableWhenExpsIsUpdated: isUpdated,
+    isUpdated: isUpdated,
     updatedEnableWhenExpressions: {
       singleExpressions: updatedEnableWhenSingleExpressions.updatedExpressions,
       repeatExpressions: updatedEnableWhenRepeatExpressions.updatedExpressions

package/src/utils/extensions.ts

@@ -598,6 +598,36 @@ export function isGroupAddItemButtonHidden(qItem: QuestionnaireItem): boolean {
   return !!extension?.valueBoolean;
 }
 
+/**
+ * Check if the item has a sdc-questionnaire-width extension
+ *
+ * @param {QuestionnaireItem} qItem - The QuestionnaireItem to check.
+ * @returns {number | undefined} The numeric value of the columnWidth extension, if present.
+ *
+ * @author Janardhan Vignarajan
+ */
+export function getColumnWidth(qItem: QuestionnaireItem): string | undefined {
+  const extension = qItem.extension?.find(
+    (extension: Extension) =>
+      extension.url === 'http://hl7.org/fhir/uv/sdc/StructureDefinition/sdc-questionnaire-width'
+  );
+
+  // Check if valueQuantity exists and if value is a "number" type
+  if (extension?.valueQuantity) {
+    if (typeof extension.valueQuantity.value === 'number') {
+      // if the extension.valueQuantity.code exists then return value + code, else return value + 'px'
+      // See http://hl7.org/fhir/uv/sdc/rendering.html#width.
+      if (extension.valueQuantity.code) {
+        return `${extension.valueQuantity.value}${extension.valueQuantity.code}`;
+      } else {
+        return `${extension.valueQuantity.value}px`;
+      }
+    }
+  }
+
+  return undefined;
+}
+
 /**
  * Check if the QuestionnaireItem has a 'showRepopulateButton' extension to show a sync button for granular repopulation.
  */

package/src/utils/extractObservation.ts

@@ -394,7 +394,8 @@ export function buildBundleFromObservationArray(observations: Observation[]): Bu
     meta: {
       tag: [
         {
-          code: '@aehrc/smart-forms-renderer:generated'
+          code: '@aehrc/smart-forms-renderer:generated',
+          system: 'urn:aehrc:sdc-template-extract'
         }
       ]
     },

package/src/utils/fhirpath.ts

@@ -18,10 +18,8 @@
 import fhirpath from 'fhirpath';
 import fhirpath_r4_model from 'fhirpath/fhir-context/r4';
 import type { Expression, QuestionnaireResponse, QuestionnaireResponseItem } from 'fhir/r4';
-import type { CalculatedExpression } from '../interfaces/calculatedExpression.interface';
 import type { EnableWhenExpressions } from '../interfaces/enableWhen.interface';
 import { evaluateEnableWhenExpressions } from './enableWhenExpression';
-import { evaluateCalculatedExpressions } from './calculatedExpression';
 import { evaluateTargetConstraints } from './targetConstraint';
 import type { TargetConstraint } from '../interfaces/targetConstraint.interface';
 import type { Variables, VariableXFhirQuery } from '../interfaces';
@@ -30,164 +28,149 @@ import type { ComputedQRItemUpdates } from '../interfaces/computedUpdates.interf
 import type { AnswerOptionsToggleExpression } from '../interfaces/answerOptionsToggleExpression.interface';
 import { evaluateAnswerOptionsToggleExpressions } from './answerOptionsToggleExpressions';
 
-interface EvaluateUpdatedExpressionsParams {
-  updatedResponse: QuestionnaireResponse;
-  updatedResponseItemMap: Record<string, QuestionnaireResponseItem[]>;
-  targetConstraints: Record<string, TargetConstraint>;
-  answerOptionsToggleExpressions: Record<string, AnswerOptionsToggleExpression[]>;
-  calculatedExpressions: Record<string, CalculatedExpression[]>;
-  enableWhenExpressions: EnableWhenExpressions;
-  variables: Variables;
-  processedValueSets: Record<string, any>;
-  existingFhirPathContext: Record<string, any>;
-  fhirPathTerminologyCache: Record<string, any>;
-  terminologyServerUrl: string;
+interface ExpressionUpdate<T> {
+  isUpdated: boolean;
+  value: T;
 }
 
-export async function evaluateUpdatedExpressions(
-  params: EvaluateUpdatedExpressionsParams
+export async function evaluateOtherExpressions(
+  updatedResponse: QuestionnaireResponse,
+  updatedResponseItemMap: Record<string, QuestionnaireResponseItem[]>,
+  variables: Variables,
+  existingFhirPathContext: Record<string, any>,
+  existingFhirPathTerminologyCache: Record<string, any>,
+  targetConstraints: Record<string, TargetConstraint>,
+  enableWhenExpressions: EnableWhenExpressions,
+  answerOptionsToggleExpressions: Record<string, AnswerOptionsToggleExpression[]>,
+  processedValueSets: Record<string, any>,
+  terminologyServerUrl: string
 ): Promise<{
-  isUpdated: boolean;
-  updatedTargetConstraints: Record<string, TargetConstraint>;
-  updatedAnswerOptionsToggleExpressions: Record<string, AnswerOptionsToggleExpression[]>;
-  updatedEnableWhenExpressions: EnableWhenExpressions;
-  updatedCalculatedExpressions: Record<string, CalculatedExpression[]>;
-  updatedProcessedValueSets: Record<string, any>;
   updatedFhirPathContext: Record<string, any>;
-  fhirPathTerminologyCache: Record<string, any>;
+  updatedFhirPathTerminologyCache: Record<string, any>;
+  targetConstraintsUpdate: ExpressionUpdate<Record<string, TargetConstraint>>;
+  enableWhenExpressionsUpdate: ExpressionUpdate<EnableWhenExpressions>;
+  answerOptionsToggleExpressionsUpdate: ExpressionUpdate<
+    Record<string, AnswerOptionsToggleExpression[]>
+  >;
+  processedValueSetsUpdate: ExpressionUpdate<Record<string, any>>;
   computedQRItemUpdates: ComputedQRItemUpdates;
 }> {
-  const {
-    updatedResponse,
-    updatedResponseItemMap,
-    targetConstraints,
-    answerOptionsToggleExpressions,
-    enableWhenExpressions,
-    calculatedExpressions,
-    processedValueSets,
-    variables,
-    existingFhirPathContext,
-    terminologyServerUrl
-  } = params;
-  let { fhirPathTerminologyCache } = params;
-
+  // Performance check: Check if there are any expressions to be updated before proceeding with eval logic
   const noExpressionsToBeUpdated =
+    Object.keys(targetConstraints).length === 0 &&
     Object.keys(enableWhenExpressions).length === 0 &&
-    Object.keys(calculatedExpressions).length === 0;
+    Object.keys(answerOptionsToggleExpressions).length === 0 &&
+    Object.keys(processedValueSets).length === 0;
+
   if (noExpressionsToBeUpdated) {
     return {
-      isUpdated: false,
-      updatedTargetConstraints: targetConstraints,
-      updatedAnswerOptionsToggleExpressions: answerOptionsToggleExpressions,
-      updatedEnableWhenExpressions: enableWhenExpressions,
-      updatedCalculatedExpressions: calculatedExpressions,
-      updatedProcessedValueSets: processedValueSets,
       updatedFhirPathContext: existingFhirPathContext,
-      fhirPathTerminologyCache,
+      updatedFhirPathTerminologyCache: existingFhirPathTerminologyCache,
+      targetConstraintsUpdate: {
+        isUpdated: false,
+        value: targetConstraints
+      },
+      enableWhenExpressionsUpdate: {
+        isUpdated: false,
+        value: enableWhenExpressions
+      },
+      answerOptionsToggleExpressionsUpdate: {
+        isUpdated: false,
+        value: answerOptionsToggleExpressions
+      },
+      processedValueSetsUpdate: {
+        isUpdated: false,
+        value: processedValueSets
+      },
       computedQRItemUpdates: {}
     };
   }
 
+  // Create a new fhirPathContext based on the updated response and variables
   const computedQRItemUpdates: ComputedQRItemUpdates = {};
-  const fhirPathEvalResult = await createFhirPathContext(
+  const {
+    fhirPathContext: updatedFhirPathContext,
+    fhirPathTerminologyCache: updatedFhirPathTerminologyCache
+  } = await createFhirPathContext(
     updatedResponse,
     updatedResponseItemMap,
     variables,
     existingFhirPathContext,
-    fhirPathTerminologyCache,
+    existingFhirPathTerminologyCache,
     terminologyServerUrl
   );
 
-  const updatedFhirPathContext = fhirPathEvalResult.fhirPathContext;
-  fhirPathTerminologyCache = fhirPathEvalResult.fhirPathTerminologyCache;
-
   // Update targetConstraints
-  const { targetConstraintsIsUpdated, updatedTargetConstraints } = await evaluateTargetConstraints(
-    updatedFhirPathContext,
-    fhirPathTerminologyCache,
-    targetConstraints,
-    terminologyServerUrl
-  );
-
-  // Update answerOptionsToggleExpressions
-  const {
-    answerOptionsToggleExpressionsIsUpdated,
-    updatedAnswerOptionsToggleExpressions,
-    computedNewAnswers: computedNewAnswersAnswerOptionsToggleExpressions
-  } = await evaluateAnswerOptionsToggleExpressions(
-    updatedFhirPathContext,
-    fhirPathTerminologyCache,
-    answerOptionsToggleExpressions,
-    terminologyServerUrl
-  );
+  const { isUpdated: targetConstraintsUpdated, updatedTargetConstraints } =
+    await evaluateTargetConstraints(
+      updatedFhirPathContext,
+      updatedFhirPathTerminologyCache,
+      targetConstraints,
+      terminologyServerUrl
+    );
 
   // Update enableWhenExpressions
-  const { enableWhenExpsIsUpdated, updatedEnableWhenExpressions } =
+  const { isUpdated: enableWhenExpressionsUpdated, updatedEnableWhenExpressions } =
     await evaluateEnableWhenExpressions(
       updatedFhirPathContext,
-      fhirPathTerminologyCache,
+      updatedFhirPathTerminologyCache,
       enableWhenExpressions,
       terminologyServerUrl
     );
 
-  // Update calculatedExpressions
+  // Update answerOptionsToggleExpressions
+  // Add generated computed answers to computedQRItemUpdates - clear the item because the previous answers may no longer be valid
   const {
-    calculatedExpsIsUpdated,
-    updatedCalculatedExpressions,
-    computedNewAnswers: computedNewAnswersCalculatedExpressions
-  } = await evaluateCalculatedExpressions(
+    isUpdated: answerOptionsToggleExpressionsUpdated,
+    updatedAnswerOptionsToggleExpressions,
+    computedNewAnswers: computedNewAnswersAnswerOptionsToggleExpressions
+  } = await evaluateAnswerOptionsToggleExpressions(
     updatedFhirPathContext,
-    fhirPathTerminologyCache,
-    calculatedExpressions,
+    updatedFhirPathTerminologyCache,
+    answerOptionsToggleExpressions,
     terminologyServerUrl
   );
 
+  for (const linkId in computedNewAnswersAnswerOptionsToggleExpressions) {
+    computedQRItemUpdates[linkId] = null;
+  }
+
   // Update dynamic value sets
+  // Add generated computed answers to computedQRItemUpdates - clear the item because the previous answers may no longer be valid
   const {
-    processedValueSetsIsUpdated,
+    isUpdated: processedValueSetsUpdated,
     updatedProcessedValueSets,
     computedNewAnswers: computedNewAnswersDynamicValueSets
   } = await evaluateDynamicValueSets(
     updatedFhirPathContext,
-    fhirPathTerminologyCache,
+    updatedFhirPathTerminologyCache,
     processedValueSets,
     terminologyServerUrl
   );
 
-  // Have a process here to find their QRItems and assign updates based on the computedNewAnswers
-  // In the case of dynamic value sets, just clear the existing answers
-  // Eventually we want to expand this to calculatedExpressions
-  for (const linkId in computedNewAnswersCalculatedExpressions) {
-    // FIXME - this implementation is designed to only work on null for now, if we want to actually apply new answer updates, need to have Questionnaire input param
-    if (computedNewAnswersCalculatedExpressions[linkId] === null) {
-      computedQRItemUpdates[linkId] = null;
-    }
-  }
-
   for (const linkId in computedNewAnswersDynamicValueSets) {
     computedQRItemUpdates[linkId] = null;
   }
 
-  for (const linkId in computedNewAnswersAnswerOptionsToggleExpressions) {
-    computedQRItemUpdates[linkId] = null;
-  }
-
-  const isUpdated =
-    enableWhenExpsIsUpdated ||
-    calculatedExpsIsUpdated ||
-    targetConstraintsIsUpdated ||
-    answerOptionsToggleExpressionsIsUpdated ||
-    processedValueSetsIsUpdated;
-
   return {
-    isUpdated,
-    updatedTargetConstraints,
-    updatedAnswerOptionsToggleExpressions,
-    updatedEnableWhenExpressions,
-    updatedCalculatedExpressions,
-    updatedProcessedValueSets,
     updatedFhirPathContext,
-    fhirPathTerminologyCache,
+    updatedFhirPathTerminologyCache,
+    targetConstraintsUpdate: {
+      isUpdated: targetConstraintsUpdated,
+      value: updatedTargetConstraints
+    },
+    enableWhenExpressionsUpdate: {
+      isUpdated: enableWhenExpressionsUpdated,
+      value: updatedEnableWhenExpressions
+    },
+    answerOptionsToggleExpressionsUpdate: {
+      isUpdated: answerOptionsToggleExpressionsUpdated,
+      value: updatedAnswerOptionsToggleExpressions
+    },
+    processedValueSetsUpdate: {
+      isUpdated: processedValueSetsUpdated,
+      value: updatedProcessedValueSets
+    },
     computedQRItemUpdates
   };
 }
@@ -284,8 +267,7 @@ export async function evaluateLinkIdVariables(
 
   for (const variable of linkIdVariables) {
     if (variable.expression && variable.name) {
-      const cacheKey = JSON.stringify(variable.expression); // Use expression as cache key
-      if (fhirPathTerminologyCache[cacheKey]) {
+      if (isExpressionCached(variable.expression, fhirPathTerminologyCache)) {
         continue;
       }
 
@@ -303,11 +285,12 @@ export async function evaluateLinkIdVariables(
             terminologyUrl: terminologyServerUrl
           }
         );
-        fhirPathContext[`${variable.name}`] = await handleFhirPathResult(fhirPathResult);
+        const result = await handleFhirPathResult(fhirPathResult);
+        fhirPathContext[`${variable.name}`] = result;
 
         // If fhirPathResult is an async terminology call, cache the result
         if (fhirPathResult instanceof Promise) {
-          fhirPathTerminologyCache[cacheKey] = fhirPathContext[`${variable.name}`];
+          cacheTerminologyResult(variable.expression, result, fhirPathTerminologyCache);
         }
       } catch (e) {
         console.warn(e.message, `LinkId: ${linkId}\nExpression: ${variable.expression}`);
@@ -335,8 +318,7 @@ export async function evaluateQuestionnaireLevelVariables(
 
   for (const variable of questionnaireLevelVariables) {
     if (variable.expression) {
-      const cacheKey = JSON.stringify(variable.expression); // Use expression as cache key
-      if (fhirPathTerminologyCache[cacheKey]) {
+      if (isExpressionCached(variable.expression, fhirPathTerminologyCache)) {
         continue;
       }
 
@@ -355,11 +337,12 @@ export async function evaluateQuestionnaireLevelVariables(
           }
         );
 
-        fhirPathContext[`${variable.name}`] = await handleFhirPathResult(fhirPathResult);
+        const result = await handleFhirPathResult(fhirPathResult);
+        fhirPathContext[`${variable.name}`] = result;
 
         // If fhirPathResult is an async terminology call, cache the result
         if (fhirPathResult instanceof Promise) {
-          fhirPathTerminologyCache[cacheKey] = fhirPathContext[`${variable.name}`];
+          cacheTerminologyResult(variable.expression, result, fhirPathTerminologyCache);
         }
       } catch (e) {
         console.warn(e.message, `Questionnaire-level\nExpression: ${variable.expression}`);
@@ -380,3 +363,45 @@ export async function handleFhirPathResult(result: any[] | Promise<any[]>) {
 
   return result;
 }
+
+/**
+ * Determines whether a FHIRPath expression result is cached.
+ *
+ * Expressions containing variables (e.g. `%something`) are never considered cached, because we can never know what a variable resolves to at runtime.
+ *
+ * @param {string} expression - The FHIRPath expression to check.
+ * @param {Record<string, any>} fhirPathTerminologyCache - Object storing cached expression results.
+ * @returns {boolean} `true` if the expression is cached and contains no variables; otherwise `false`.
+ */
+export function isExpressionCached(
+  expression: string,
+  fhirPathTerminologyCache: Record<string, any>
+): boolean {
+  // Expressions with variables are never cached
+  if (expression.includes('%')) {
+    return false;
+  }
+
+  // Check if expression exists in cache
+  return Object.prototype.hasOwnProperty.call(fhirPathTerminologyCache, expression);
+}
+
+/**
+ * Caches the result of a FHIRPath evaluation if it was an asynchronous terminology call and the expression contains no variables (e.g. `%something`).
+ *
+ * @param {string} expression - The FHIRPath expression that was evaluated.
+ * @param {any} result - The evaluated result of the expression with async resolved.
+ * @param {Record<string, any>} fhirPathTerminologyCache - The cache object to store results.
+ */
+export function cacheTerminologyResult(
+  expression: string,
+  result: any,
+  fhirPathTerminologyCache: Record<string, any>
+) {
+  // Skip caching for expressions with variables
+  if (expression.includes('%')) {
+    return;
+  }
+
+  fhirPathTerminologyCache[expression] = result;
+}