@aehrc/smart-forms-renderer 0.25.2 → 0.26.0

package/src/hooks/useStringCalculatedExpression.ts

@@ -16,8 +16,7 @@
  */
 
 import { useEffect, useState } from 'react';
-import { createEmptyQrItem } from '../utils/qrItem';
-import type { QuestionnaireItem, QuestionnaireResponseItem } from 'fhir/r4';
+import type { QuestionnaireItem } from 'fhir/r4';
 import { useQuestionnaireStore } from '../stores';
 
 interface UseStringCalculatedExpression {
@@ -27,14 +26,14 @@ interface UseStringCalculatedExpression {
 interface useStringCalculatedExpressionProps {
   qItem: QuestionnaireItem;
   inputValue: string;
-  setInputValue: (value: string) => void;
-  onQrItemChange: (qrItem: QuestionnaireResponseItem) => void;
+  onChangeByCalcExpressionString: (newValueString: string) => void;
+  onChangeByCalcExpressionNull: () => void;
 }
 
 function useStringCalculatedExpression(
   props: useStringCalculatedExpressionProps
 ): UseStringCalculatedExpression {
-  const { qItem, inputValue, setInputValue, onQrItemChange } = props;
+  const { qItem, inputValue, onChangeByCalcExpressionString, onChangeByCalcExpressionNull } = props;
 
   const calculatedExpressions = useQuestionnaireStore.use.calculatedExpressions();
 
@@ -53,7 +52,9 @@ function useStringCalculatedExpression(
       // only update if calculated value is different from current value
       if (
         calcExpression.value !== inputValue &&
-        (typeof calcExpression.value === 'string' || typeof calcExpression.value === 'number')
+        (typeof calcExpression.value === 'string' ||
+          typeof calcExpression.value === 'number' ||
+          calcExpression.value === null)
       ) {
         // update ui to show calculated value changes
         setCalcExpUpdated(true);
@@ -61,17 +62,19 @@ function useStringCalculatedExpression(
           setCalcExpUpdated(false);
         }, 500);
 
-        const updatedInputValue =
+        // calculatedExpression value is null
+        if (calcExpression.value === null) {
+          onChangeByCalcExpressionNull();
+          return;
+        }
+
+        // calculatedExpression value is a string or number
+        const newInputValue =
           typeof calcExpression.value === 'string'
             ? calcExpression.value
             : calcExpression.value.toString();
 
-        // update questionnaireResponse
-        setInputValue(updatedInputValue);
-        onQrItemChange({
-          ...createEmptyQrItem(qItem),
-          answer: [{ valueString: updatedInputValue }]
-        });
+        onChangeByCalcExpressionString(newInputValue);
       }
     },
     // Only trigger this effect if calculatedExpression of item changes

package/src/interfaces/calculatedExpression.interface.ts

@@ -1,5 +1,5 @@
 export interface CalculatedExpression {
   expression: string;
   from: 'item' | 'item._text';
-  value?: number | string | boolean | object;
+  value?: number | string | boolean | object | null;
 }

package/src/stores/questionnaireResponseStore.ts

@@ -16,7 +16,12 @@
  */
 
 import { createStore } from 'zustand/vanilla';
-import type { OperationOutcome, Questionnaire, QuestionnaireResponse } from 'fhir/r4';
+import type {
+  OperationOutcome,
+  Questionnaire,
+  QuestionnaireResponse,
+  QuestionnaireResponseItem
+} from 'fhir/r4';
 import { emptyResponse } from '../utils/emptyResource';
 import cloneDeep from 'lodash.clonedeep';
 import type { Diff } from 'deep-diff';
@@ -24,10 +29,12 @@ import { diff } from 'deep-diff';
 import { createSelectors } from './selector';
 import { validateQuestionnaire } from '../utils/validateQuestionnaire';
 import { questionnaireStore } from './questionnaireStore';
+import { createQuestionnaireResponseItemMap } from '../utils/questionnaireResponseStoreUtils/updatableResponseItems';
 
 interface QuestionnaireResponseStoreType {
   sourceResponse: QuestionnaireResponse;
   updatableResponse: QuestionnaireResponse;
+  updatableResponseItems: Record<string, QuestionnaireResponseItem[]>;
   formChangesHistory: (Diff<QuestionnaireResponse, QuestionnaireResponse>[] | null)[];
   invalidItems: Record<string, OperationOutcome>;
   responseIsValid: boolean;
@@ -47,6 +54,7 @@ export const questionnaireResponseStore = createStore<QuestionnaireResponseStore
   (set, get) => ({
     sourceResponse: cloneDeep(emptyResponse),
     updatableResponse: cloneDeep(emptyResponse),
+    updatableResponseItems: {},
     formChangesHistory: [],
     invalidItems: {},
     responseIsValid: true,
@@ -74,13 +82,15 @@ export const questionnaireResponseStore = createStore<QuestionnaireResponseStore
     buildSourceResponse: (questionnaireResponse: QuestionnaireResponse) => {
       set(() => ({
         sourceResponse: questionnaireResponse,
-        updatableResponse: questionnaireResponse
+        updatableResponse: questionnaireResponse,
+        updatableResponseItems: createQuestionnaireResponseItemMap(questionnaireResponse)
       }));
     },
     setUpdatableResponseAsPopulated: (populatedResponse: QuestionnaireResponse) => {
       const formChanges = diff(get().updatableResponse, populatedResponse) ?? null;
       set(() => ({
         updatableResponse: populatedResponse,
+        updatableResponseItems: createQuestionnaireResponseItemMap(populatedResponse),
         formChangesHistory: [...get().formChangesHistory, formChanges]
       }));
     },
@@ -88,6 +98,7 @@ export const questionnaireResponseStore = createStore<QuestionnaireResponseStore
       const formChanges = diff(get().updatableResponse, updatedResponse) ?? null;
       set(() => ({
         updatableResponse: updatedResponse,
+        updatableResponseItems: createQuestionnaireResponseItemMap(updatedResponse),
         formChangesHistory: [...get().formChangesHistory, formChanges]
       }));
     },
@@ -95,17 +106,20 @@ export const questionnaireResponseStore = createStore<QuestionnaireResponseStore
       set(() => ({
         sourceResponse: savedResponse,
         updatableResponse: savedResponse,
+        updatableResponseItems: createQuestionnaireResponseItemMap(savedResponse),
         formChangesHistory: []
       })),
     setUpdatableResponseAsEmpty: (clearedResponse: QuestionnaireResponse) =>
       set(() => ({
         updatableResponse: clearedResponse,
+        updatableResponseItems: createQuestionnaireResponseItemMap(clearedResponse),
         formChangesHistory: []
       })),
     destroySourceResponse: () =>
       set(() => ({
         sourceResponse: cloneDeep(emptyResponse),
         updatableResponse: cloneDeep(emptyResponse),
+        updatableResponseItems: createQuestionnaireResponseItemMap(cloneDeep(emptyResponse)),
         formChangesHistory: []
       }))
   })

package/src/stores/questionnaireStore.ts

@@ -45,6 +45,7 @@ import { terminologyServerStore } from './terminologyServerStore';
 import { createSelectors } from './selector';
 import { mutateRepeatEnableWhenExpressionInstances } from '../utils/enableWhenExpression';
 import { questionnaireResponseStore } from './questionnaireResponseStore';
+import { createQuestionnaireResponseItemMap } from '../utils/questionnaireResponseStoreUtils/updatableResponseItems';
 
 interface QuestionnaireStoreType {
   sourceQuestionnaire: Questionnaire;
@@ -232,6 +233,7 @@ export const questionnaireStore = createStore<QuestionnaireStoreType>()((set, ge
 
     const { updatedEnableWhenExpressions, isUpdated } = mutateRepeatEnableWhenExpressionInstances({
       questionnaireResponse: questionnaireResponseStore.getState().updatableResponse,
+      questionnaireResponseItemMap: questionnaireResponseStore.getState().updatableResponseItems,
       variablesFhirPath: get().variables.fhirPathVariables,
       existingFhirPathContext: get().fhirPathContext,
       enableWhenExpressions: enableWhenExpressions,
@@ -250,6 +252,7 @@ export const questionnaireStore = createStore<QuestionnaireStoreType>()((set, ge
   toggleEnableWhenActivation: (isActivated: boolean) =>
     set(() => ({ enableWhenIsActivated: isActivated })),
   updateExpressions: (updatedResponse: QuestionnaireResponse) => {
+    const updatedResponseItemMap = createQuestionnaireResponseItemMap(updatedResponse);
     const {
       isUpdated,
       updatedEnableWhenExpressions,
@@ -257,6 +260,7 @@ export const questionnaireStore = createStore<QuestionnaireStoreType>()((set, ge
       updatedFhirPathContext
     } = evaluateUpdatedExpressions({
       updatedResponse,
+      updatedResponseItemMap,
       enableWhenExpressions: get().enableWhenExpressions,
       calculatedExpressions: get().calculatedExpressions,
       variablesFhirPath: get().variables.fhirPathVariables,
@@ -284,8 +288,11 @@ export const questionnaireStore = createStore<QuestionnaireStoreType>()((set, ge
       }
     })),
   updatePopulatedProperties: (populatedResponse: QuestionnaireResponse, persistTabIndex) => {
+    const initialResponseItemMap = createQuestionnaireResponseItemMap(populatedResponse);
+
     const evaluateInitialCalculatedExpressionsResult = evaluateInitialCalculatedExpressions({
       initialResponse: populatedResponse,
+      initialResponseItemMap: initialResponseItemMap,
       calculatedExpressions: get().calculatedExpressions,
       variablesFhirPath: get().variables.fhirPathVariables,
       existingFhirPathContext: get().fhirPathContext

package/src/utils/calculatedExpression.ts

@@ -37,6 +37,7 @@ import dayjs from 'dayjs';
 
 interface EvaluateInitialCalculatedExpressionsParams {
   initialResponse: QuestionnaireResponse;
+  initialResponseItemMap: Record<string, QuestionnaireResponseItem[]>;
   calculatedExpressions: Record<string, CalculatedExpression[]>;
   variablesFhirPath: Record<string, Expression[]>;
   existingFhirPathContext: Record<string, any>;
@@ -48,8 +49,13 @@ export function evaluateInitialCalculatedExpressions(
   initialCalculatedExpressions: Record<string, CalculatedExpression[]>;
   updatedFhirPathContext: Record<string, any>;
 } {
-  const { initialResponse, calculatedExpressions, variablesFhirPath, existingFhirPathContext } =
-    params;
+  const {
+    initialResponse,
+    initialResponseItemMap,
+    calculatedExpressions,
+    variablesFhirPath,
+    existingFhirPathContext
+  } = params;
 
   // Return early if initialResponse is empty or there are no calculated expressions to evaluate
   if (
@@ -65,10 +71,11 @@ export function evaluateInitialCalculatedExpressions(
   const initialCalculatedExpressions: Record<string, CalculatedExpression[]> = {
     ...calculatedExpressions
   };
+
   const updatedFhirPathContext = createFhirPathContext(
     initialResponse,
-    variablesFhirPath,
-    existingFhirPathContext
+    initialResponseItemMap,
+    variablesFhirPath
   );
 
   for (const linkId in initialCalculatedExpressions) {
@@ -83,7 +90,8 @@ export function evaluateInitialCalculatedExpressions(
           fhirpath_r4_model
         );
 
-        if (!_isEqual(calcExpression.value, result[0])) {
+        // Only update calculatedExpressions if length of result array > 0
+        if (result.length > 0 && !_isEqual(calcExpression.value, result[0])) {
           calcExpression.value = result[0];
         }
       } catch (e) {
@@ -124,11 +132,17 @@ export function evaluateCalculatedExpressions(
           fhirpath_r4_model
         );
 
-        if (result.length > 0) {
-          if (!_isEqual(calcExpression.value, result[0])) {
-            isUpdated = true;
-            calcExpression.value = result[0];
-          }
+        // Update calculatedExpressions if length of result array > 0
+        // Only update when current calcExpression value is different from the result, otherwise it will result in an infinite loop as per issue #733
+        if (result.length > 0 && !_isEqual(calcExpression.value, result[0])) {
+          isUpdated = true;
+          calcExpression.value = result[0];
+        }
+
+        // Update calculatedExpression value to null if no result is returned
+        if (result.length === 0 && calcExpression.value !== null) {
+          isUpdated = true;
+          calcExpression.value = null;
         }
       } catch (e) {
         console.warn(e.message, `LinkId: ${linkId}\nExpression: ${calcExpression.expression}`);

package/src/utils/enableWhenExpression.ts

@@ -15,7 +15,7 @@
  * limitations under the License.
  */
 
-import type { Expression, QuestionnaireResponse } from 'fhir/r4';
+import type { Expression, QuestionnaireResponse, QuestionnaireResponseItem } from 'fhir/r4';
 import { createFhirPathContext } from './fhirpath';
 import fhirpath from 'fhirpath';
 import fhirpath_r4_model from 'fhirpath/fhir-context/r4';
@@ -27,9 +27,9 @@ import type {
 
 interface EvaluateInitialEnableWhenExpressionsParams {
   initialResponse: QuestionnaireResponse;
+  initialResponseItemMap: Record<string, QuestionnaireResponseItem[]>;
   enableWhenExpressions: EnableWhenExpressions;
   variablesFhirPath: Record<string, Expression[]>;
-  existingFhirPathContext: Record<string, any>;
 }
 
 export function evaluateInitialEnableWhenExpressions(
@@ -38,7 +38,7 @@ export function evaluateInitialEnableWhenExpressions(
   initialEnableWhenExpressions: EnableWhenExpressions;
   updatedFhirPathContext: Record<string, any>;
 } {
-  const { initialResponse, enableWhenExpressions, variablesFhirPath, existingFhirPathContext } =
+  const { initialResponse, initialResponseItemMap, enableWhenExpressions, variablesFhirPath } =
     params;
 
   const initialEnableWhenExpressions: EnableWhenExpressions = {
@@ -46,8 +46,8 @@ export function evaluateInitialEnableWhenExpressions(
   };
   const updatedFhirPathContext = createFhirPathContext(
     initialResponse,
-    variablesFhirPath,
-    existingFhirPathContext
+    initialResponseItemMap,
+    variablesFhirPath
   );
 
   const initialEnableWhenSingleExpressions = evaluateEnableWhenSingleExpressions(
@@ -85,12 +85,18 @@ function evaluateEnableWhenSingleExpressions(
       const result = fhirpath.evaluate('', expression, updatedFhirPathContext, fhirpath_r4_model);
 
       // Update enableWhenExpressions if length of result array > 0
-      // Only update when current isEnabled value is different from the result, otherwise it will result in am infinite loop as per #733
+      // Only update when current isEnabled value is different from the result, otherwise it will result in an infinite loop as per issue #733
       if (result.length > 0 && initialValue !== result[0] && typeof result[0] === 'boolean') {
         enableWhenSingleExpressions[linkId].isEnabled = result[0];
         isUpdated = true;
       }
 
+      // Update isEnabled value to false if no result is returned
+      if (result.length === 0 && initialValue !== false) {
+        enableWhenSingleExpressions[linkId].isEnabled = false;
+        isUpdated = true;
+      }
+
       // handle intersect edge case - evaluate() returns empty array if result is false
       if (
         enableWhenSingleExpressions[linkId].expression.includes('intersect') &&
@@ -198,6 +204,12 @@ export function evaluateEnableWhenRepeatExpressionInstance(
       isUpdated = true;
     }
 
+    // Update isEnabled value to false if no result is returned
+    if (result.length === 0 && initialValue !== false) {
+      isEnabled = false;
+      isUpdated = true;
+    }
+
     // handle intersect edge case - evaluate() returns empty array if result is false
     if (expression.includes('intersect') && result.length === 0 && initialValue !== result[0]) {
       isEnabled = false;
@@ -245,6 +257,7 @@ export function evaluateEnableWhenExpressions(
 
 interface MutateRepeatEnableWhenExpressionInstancesParams {
   questionnaireResponse: QuestionnaireResponse;
+  questionnaireResponseItemMap: Record<string, QuestionnaireResponseItem[]>;
   variablesFhirPath: Record<string, Expression[]>;
   existingFhirPathContext: Record<string, any>;
   enableWhenExpressions: EnableWhenExpressions;
@@ -258,8 +271,8 @@ export function mutateRepeatEnableWhenExpressionInstances(
 ): { updatedEnableWhenExpressions: EnableWhenExpressions; isUpdated: boolean } {
   const {
     questionnaireResponse,
+    questionnaireResponseItemMap,
     variablesFhirPath,
-    existingFhirPathContext,
     enableWhenExpressions,
     parentRepeatGroupLinkId,
     parentRepeatGroupIndex,
@@ -270,8 +283,8 @@ export function mutateRepeatEnableWhenExpressionInstances(
 
   const updatedFhirPathContext = createFhirPathContext(
     questionnaireResponse,
-    variablesFhirPath,
-    existingFhirPathContext
+    questionnaireResponseItemMap,
+    variablesFhirPath
   );
 
   let isUpdated = false;

package/src/utils/fhirpath.ts

@@ -25,6 +25,7 @@ import { evaluateCalculatedExpressions } from './calculatedExpression';
 
 interface EvaluateUpdatedExpressionsParams {
   updatedResponse: QuestionnaireResponse;
+  updatedResponseItemMap: Record<string, QuestionnaireResponseItem[]>;
   calculatedExpressions: Record<string, CalculatedExpression[]>;
   enableWhenExpressions: EnableWhenExpressions;
   variablesFhirPath: Record<string, Expression[]>;
@@ -39,6 +40,7 @@ export function evaluateUpdatedExpressions(params: EvaluateUpdatedExpressionsPar
 } {
   const {
     updatedResponse,
+    updatedResponseItemMap,
     enableWhenExpressions,
     calculatedExpressions,
     variablesFhirPath,
@@ -59,8 +61,8 @@ export function evaluateUpdatedExpressions(params: EvaluateUpdatedExpressionsPar
 
   const updatedFhirPathContext = createFhirPathContext(
     updatedResponse,
-    variablesFhirPath,
-    existingFhirPathContext
+    updatedResponseItemMap,
+    variablesFhirPath
   );
 
   // Update enableWhenExpressions
@@ -87,58 +89,52 @@ export function evaluateUpdatedExpressions(params: EvaluateUpdatedExpressionsPar
 
 export function createFhirPathContext(
   questionnaireResponse: QuestionnaireResponse,
-  variablesFhirPath: Record<string, Expression[]>,
-  existingFhirPathContext: Record<string, any>
+  questionnaireResponseItemMap: Record<string, QuestionnaireResponseItem[]>,
+  variablesFhirPath: Record<string, Expression[]>
 ): Record<string, any> {
-  let fhirPathContext = {};
-  if (Object.keys(existingFhirPathContext).length > 0) {
-    fhirPathContext = { ...fhirPathContext, ...existingFhirPathContext };
+  if (!questionnaireResponse.item) {
+    return {};
   }
 
   // Add latest resource to fhirPathContext
-  fhirPathContext = { ...fhirPathContext, resource: questionnaireResponse };
-
-  if (!questionnaireResponse.item || questionnaireResponse.item.length === 0) {
-    return fhirPathContext;
-  }
+  let fhirPathContext: Record<string, any> = { resource: questionnaireResponse };
 
-  evaluateResourceLevelFhirPath(questionnaireResponse, variablesFhirPath, fhirPathContext);
+  // Evaluate resource-level variables
+  fhirPathContext = evaluateQuestionnaireLevelVariables(
+    questionnaireResponse,
+    variablesFhirPath,
+    fhirPathContext
+  );
 
-  for (const topLevelItem of questionnaireResponse.item) {
-    evaluateFhirPathRecursive(topLevelItem, variablesFhirPath, fhirPathContext);
+  // Add variables of items that exist in questionnaireResponseItemMap into fhirPathContext
+  for (const linkId in questionnaireResponseItemMap) {
+    // For non-repeat groups, the same linkId will have only one item
+    // For repeat groups, the same linkId will have multiple items
+    for (const qrItem of questionnaireResponseItemMap[linkId]) {
+      fhirPathContext = evaluateLinkIdVariables(qrItem, variablesFhirPath, fhirPathContext);
+    }
   }
 
-  return fhirPathContext;
-}
-
-export function evaluateFhirPathRecursive(
-  item: QuestionnaireResponseItem,
-  variablesFhirPath: Record<string, Expression[]>,
-  fhirPathContext: Record<string, any>
-) {
-  const items = item.item;
-  if (items && items.length > 0) {
-    // iterate through items of item recursively
-    for (const childItem of items) {
-      evaluateFhirPathRecursive(childItem, variablesFhirPath, fhirPathContext);
-    }
+  // Items don't exist in questionnaireResponseItemMap, but we still have to add them into the fhirPathContext as empty arrays
+  for (const linkId in variablesFhirPath) {
+    fhirPathContext = addEmptyLinkIdVariables(linkId, variablesFhirPath, fhirPathContext);
   }
 
-  evaluateItemFhirPath(item, variablesFhirPath, fhirPathContext);
+  return fhirPathContext;
 }
 
-export function evaluateItemFhirPath(
+export function evaluateLinkIdVariables(
   item: QuestionnaireResponseItem,
   variablesFhirPath: Record<string, Expression[]>,
   fhirPathContext: Record<string, any>
 ) {
-  const variablesOfItem = variablesFhirPath[item.linkId];
-  if (!variablesOfItem || variablesOfItem.length === 0) {
-    return;
+  const linkIdVariables = variablesFhirPath[item.linkId];
+  if (!linkIdVariables || linkIdVariables.length === 0) {
+    return fhirPathContext;
   }
 
-  variablesOfItem.forEach((variable) => {
-    if (variable.expression) {
+  for (const variable of linkIdVariables) {
+    if (variable.expression && variable.name) {
       try {
         fhirPathContext[`${variable.name}`] = fhirpath.evaluate(
           item,
@@ -153,20 +149,43 @@ export function evaluateItemFhirPath(
         console.warn(e.message, `LinkId: ${item.linkId}\nExpression: ${variable.expression}`);
       }
     }
-  });
+  }
+
+  return fhirPathContext;
+}
+
+export function addEmptyLinkIdVariables(
+  linkId: string,
+  variablesFhirPath: Record<string, Expression[]>,
+  fhirPathContext: Record<string, any>
+) {
+  const linkIdVariables = variablesFhirPath[linkId];
+  if (!linkIdVariables || linkIdVariables.length === 0) {
+    return fhirPathContext;
+  }
+
+  for (const variable of linkIdVariables) {
+    if (variable.expression && variable.name) {
+      if (fhirPathContext[`${variable.name}`] === undefined) {
+        fhirPathContext[`${variable.name}`] = [];
+      }
+    }
+  }
+
+  return fhirPathContext;
 }
 
-export function evaluateResourceLevelFhirPath(
+export function evaluateQuestionnaireLevelVariables(
   resource: QuestionnaireResponse,
   variablesFhirPath: Record<string, Expression[]>,
   fhirPathContext: Record<string, any>
 ) {
   const questionnaireLevelVariables = variablesFhirPath['QuestionnaireLevel'];
   if (!questionnaireLevelVariables || questionnaireLevelVariables.length === 0) {
-    return;
+    return fhirPathContext;
   }
 
-  questionnaireLevelVariables.forEach((variable) => {
+  for (const variable of questionnaireLevelVariables) {
     if (variable.expression) {
       try {
         fhirPathContext[`${variable.name}`] = fhirpath.evaluate(
@@ -182,5 +201,7 @@ export function evaluateResourceLevelFhirPath(
         console.warn(e.message, `Questionnaire-level\nExpression: ${variable.expression}`);
       }
     }
-  });
+  }
+
+  return fhirPathContext;
 }

package/src/utils/initialise.ts

@@ -31,6 +31,7 @@ import type { Tabs } from '../interfaces/tab.interface';
 import { assignPopulatedAnswersToEnableWhen } from './enableWhen';
 import type { CalculatedExpression } from '../interfaces/calculatedExpression.interface';
 import { evaluateInitialCalculatedExpressions } from './calculatedExpression';
+import { createQuestionnaireResponseItemMap } from './questionnaireResponseStoreUtils/updatableResponseItems';
 
 /**
  * Initialise a conformant questionnaireResponse from a given questionnaire
@@ -345,6 +346,7 @@ export function initialiseFormFromResponse(params: initialFormFromResponseParams
     variablesFhirPath,
     tabs
   } = params;
+  const initialResponseItemMap = createQuestionnaireResponseItemMap(questionnaireResponse);
   let updatedFhirPathContext = params.fhirPathContext;
 
   const { initialisedItems, linkedQuestions } = assignPopulatedAnswersToEnableWhen(
@@ -354,15 +356,16 @@ export function initialiseFormFromResponse(params: initialFormFromResponseParams
 
   const evaluateInitialEnableWhenExpressionsResult = evaluateInitialEnableWhenExpressions({
     initialResponse: questionnaireResponse,
+    initialResponseItemMap: initialResponseItemMap,
     enableWhenExpressions: enableWhenExpressions,
-    variablesFhirPath: variablesFhirPath,
-    existingFhirPathContext: updatedFhirPathContext
+    variablesFhirPath: variablesFhirPath
   });
   const { initialEnableWhenExpressions } = evaluateInitialEnableWhenExpressionsResult;
   updatedFhirPathContext = evaluateInitialEnableWhenExpressionsResult.updatedFhirPathContext;
 
   const evaluateInitialCalculatedExpressionsResult = evaluateInitialCalculatedExpressions({
     initialResponse: questionnaireResponse,
+    initialResponseItemMap: initialResponseItemMap,
     calculatedExpressions: calculatedExpressions,
     variablesFhirPath: variablesFhirPath,
     existingFhirPathContext: updatedFhirPathContext

package/src/utils/parseInputs.ts

@@ -59,7 +59,7 @@ export function parseDecimalStringWithPrecision(input: string, precision: number
 
   // truncate decimal digits based on precision
   const parsedDecimalPoint = input.indexOf('.');
-  if (precision && parsedDecimalPoint !== -1) {
+  if (typeof precision === 'number' && parsedDecimalPoint !== -1) {
     parsedInput = parsedInput.substring(0, parsedDecimalPoint + precision + 1);
   }
 

package/src/utils/questionnaireResponseStoreUtils/updatableResponseItems.ts

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2024 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 type { QuestionnaireResponse, QuestionnaireResponseItem } from 'fhir/r4';
+
+export function createQuestionnaireResponseItemMap(
+  questionnaireResponse: QuestionnaireResponse
+): Record<string, QuestionnaireResponseItem[]> {
+  if (!questionnaireResponse.item) {
+    return {};
+  }
+
+  const questionnaireResponseItemMap: Record<string, QuestionnaireResponseItem[]> = {};
+  for (const topLevelQRItem of questionnaireResponse.item) {
+    fillQuestionnaireResponseItemMapRecursive(topLevelQRItem, questionnaireResponseItemMap);
+  }
+
+  return questionnaireResponseItemMap;
+}
+
+function fillQuestionnaireResponseItemMapRecursive(
+  qrItem: QuestionnaireResponseItem,
+  questionnaireResponseItemMap: Record<string, QuestionnaireResponseItem[]>
+) {
+  const qrItems = qrItem.item;
+  if (qrItems && qrItems.length > 0) {
+    // iterate through items of item recursively
+    for (const childQRItem of qrItems) {
+      fillQuestionnaireResponseItemMapRecursive(childQRItem, questionnaireResponseItemMap);
+    }
+  }
+
+  fillQuestionnaireResponseItemMap(qrItem, questionnaireResponseItemMap);
+}
+
+function fillQuestionnaireResponseItemMap(
+  qrItem: QuestionnaireResponseItem,
+  questionnaireResponseItemMap: Record<string, QuestionnaireResponseItem[]>
+) {
+  // linkId already exists in questionnaireResponseItemMap, it would be a repeat group
+  if (qrItem.linkId in questionnaireResponseItemMap) {
+    questionnaireResponseItemMap[qrItem.linkId].push(qrItem);
+  }
+  // Add item to questionnaireResponseItemMap
+  else {
+    questionnaireResponseItemMap[qrItem.linkId] = [qrItem];
+  }
+}