@aehrc/smart-forms-renderer 0.8.1 → 0.9.1

package/src/hooks/useDecimalCalculatedExpression.ts

@@ -16,7 +16,7 @@
  */
 
 import { useEffect, useState } from 'react';
-import { createEmptyQrItemWithUnit } from '../utils/qrItem';
+import { createEmptyQrItem } from '../utils/qrItem';
 import type { QuestionnaireItem, QuestionnaireResponseItem } from 'fhir/r4';
 import useQuestionnaireStore from '../stores/useQuestionnaireStore';
 
@@ -27,7 +27,6 @@ interface UseDecimalCalculatedExpression {
 interface useDecimalCalculatedExpressionProps {
   qItem: QuestionnaireItem;
   inputValue: string;
-  displayUnit: string;
   precision: number | null;
   setInputValue: (value: string) => void;
   onQrItemChange: (qrItem: QuestionnaireResponseItem) => void;
@@ -36,7 +35,7 @@ interface useDecimalCalculatedExpressionProps {
 function useDecimalCalculatedExpression(
   props: useDecimalCalculatedExpressionProps
 ): UseDecimalCalculatedExpression {
-  const { qItem, inputValue, displayUnit, precision, setInputValue, onQrItemChange } = props;
+  const { qItem, inputValue, precision, setInputValue, onQrItemChange } = props;
 
   const calculatedExpressions = useQuestionnaireStore((state) => state.calculatedExpressions);
 
@@ -63,7 +62,7 @@ function useDecimalCalculatedExpression(
           // update questionnaireResponse
           setInputValue(precision ? value.toFixed(precision) : value.toString());
           onQrItemChange({
-            ...createEmptyQrItemWithUnit(qItem, displayUnit),
+            ...createEmptyQrItem(qItem),
             answer: [{ valueDecimal: value }]
           });
         }

package/src/hooks/useInitialiseRepeatAnswers.ts

@@ -22,7 +22,7 @@ import { useMemo } from 'react';
 
 function useInitialiseRepeatAnswers(
   qItem: QuestionnaireItem,
-  qrItem: QuestionnaireResponseItem
+  qrItem: QuestionnaireResponseItem | null
 ): RepeatAnswer[] {
   return useMemo(
     () => {

package/src/hooks/useIntegerCalculatedExpression.ts

@@ -16,7 +16,7 @@
  */
 
 import { useEffect, useState } from 'react';
-import { createEmptyQrItemWithUnit } from '../utils/qrItem';
+import { createEmptyQrItem } from '../utils/qrItem';
 import type { QuestionnaireItem, QuestionnaireResponseItem } from 'fhir/r4';
 import useQuestionnaireStore from '../stores/useQuestionnaireStore';
 
@@ -27,7 +27,6 @@ interface UseIntegerCalculatedExpression {
 interface useIntegerCalculatedExpressionProps {
   qItem: QuestionnaireItem;
   inputValue: number;
-  displayUnit: string;
   setInputValue: (value: number) => void;
   onQrItemChange: (qrItem: QuestionnaireResponseItem) => void;
 }
@@ -35,7 +34,7 @@ interface useIntegerCalculatedExpressionProps {
 function useIntegerCalculatedExpression(
   props: useIntegerCalculatedExpressionProps
 ): UseIntegerCalculatedExpression {
-  const { qItem, inputValue, displayUnit, setInputValue, onQrItemChange } = props;
+  const { qItem, inputValue, setInputValue, onQrItemChange } = props;
 
   const calculatedExpressions = useQuestionnaireStore((state) => state.calculatedExpressions);
 
@@ -56,7 +55,7 @@ function useIntegerCalculatedExpression(
         // update questionnaireResponse
         setInputValue(calcExpression.value);
         onQrItemChange({
-          ...createEmptyQrItemWithUnit(qItem, displayUnit),
+          ...createEmptyQrItem(qItem),
           answer: [{ valueInteger: calcExpression.value }]
         });
       }

package/src/hooks/useSliderExtensions.ts

@@ -0,0 +1,50 @@
+/*
+ * Copyright 2023 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 { getTextDisplayLower, getTextDisplayUpper } from '../utils/itemControl';
+import type { QuestionnaireItem } from 'fhir/r4';
+import { getMaxValue, getMinValue, getSliderStepValue } from '../utils/slider';
+
+const defaultMinValue = 0;
+const defaultMinLabel = '0';
+
+const defaultMaxValue = 100;
+const defaultMaxLabel = '100';
+
+const defaultStepValue = 1;
+
+interface SliderExtensions {
+  minValue: number;
+  minLabel: string;
+  maxValue: number;
+  maxLabel: string;
+  stepValue: number;
+}
+
+function useSliderExtensions(qItem: QuestionnaireItem): SliderExtensions {
+  const minValue = getMinValue(qItem) ?? defaultMinValue;
+  const maxValue = getMaxValue(qItem) ?? defaultMaxValue;
+  return {
+    minValue: minValue,
+    minLabel: getTextDisplayLower(qItem) ?? minValue.toString() ?? defaultMinLabel,
+    maxValue: maxValue,
+    maxLabel: getTextDisplayUpper(qItem) ?? maxValue.toString() ?? defaultMaxLabel,
+    stepValue: getSliderStepValue(qItem) ?? defaultStepValue
+  };
+}
+
+export default useSliderExtensions;

package/src/hooks/useTerminologyServerQuery.ts

@@ -71,8 +71,6 @@ function useTerminologyServerQuery(
     }
   );
 
-  console.log(isFetching);
-
   if (error) {
     console.warn('Ontoserver query failed. Details below: \n' + error);
     feedback = {

package/src/index.ts

@@ -80,32 +80,35 @@ export function removeHiddenAnswersFromResponse(
 }
 
 /**
- * Re-populate stuff
+ * Compare latest data from the server with the current QuestionnaireResponse and decide items to re-populate.
  *
  * @author Sean Fong
  */
 export function generateItemsToRepopulate(populatedResponse: QuestionnaireResponse) {
   const sourceQuestionnaire = useQuestionnaireStore.getState().sourceQuestionnaire;
-  const itemTypes = useQuestionnaireStore.getState().itemTypes;
   const tabs = useQuestionnaireStore.getState().tabs;
   const updatableResponse = useQuestionnaireResponseStore.getState().updatableResponse;
-  console.log(updatableResponse);
+  const enableWhenIsActivated = useQuestionnaireStore.getState().enableWhenIsActivated;
+  const enableWhenItems = useQuestionnaireStore.getState().enableWhenItems;
+  const enableWhenExpressions = useQuestionnaireStore.getState().enableWhenExpressions;
 
-  return getItemsToRepopulate(
+  return getItemsToRepopulate({
     sourceQuestionnaire,
-    itemTypes,
     tabs,
     populatedResponse,
-    updatableResponse
-  );
+    updatableResponse,
+    enableWhenIsActivated,
+    enableWhenItems,
+    enableWhenExpressions
+  });
 }
 
 /**
- * Re-populate stuff
+ * Re-populate checked items in the re-population dialog into the current QuestionnaireResponse.
  *
  * @author Sean Fong
  */
-export function repopulate(checkedItemsToRepopulate: Record<string, ItemToRepopulate>) {
+export function repopulateResponse(checkedItemsToRepopulate: Record<string, ItemToRepopulate>) {
   const sourceQuestionnaire = useQuestionnaireStore.getState().sourceQuestionnaire;
   const updatableResponse = useQuestionnaireResponseStore.getState().updatableResponse;
 

package/src/interfaces/questionnaireStore.interface.ts

@@ -34,4 +34,5 @@ export interface QuestionnaireModel {
   answerExpressions: Record<string, AnswerExpression>;
   processedValueSetCodings: Record<string, Coding[]>;
   processedValueSetUrls: Record<string, string>;
+  fhirPathContext: Record<string, any>;
 }

package/src/interfaces/renderProps.interface.ts

@@ -16,8 +16,9 @@
  */
 
 import type { QrRepeatGroup } from './repeatGroup.interface';
+import type { QuestionnaireResponseItem } from 'fhir/r4';
 
-export interface PropsWithQrItemChangeHandler<QuestionnaireResponseItem> {
+export interface PropsWithQrItemChangeHandler {
   onQrItemChange: (qrItem: QuestionnaireResponseItem) => unknown;
 }
 
@@ -33,8 +34,8 @@ export interface PropsWithIsTabledAttribute {
   isTabled: boolean;
 }
 
-export interface PropsWithTextShownAttribute {
-  textShown?: boolean;
+export interface PropsWithShowMinimalViewAttribute {
+  showMinimalView?: boolean;
 }
 
 export interface PropsWithParentIsReadOnlyAttribute {

package/src/stores/useQuestionnaireStore.ts

@@ -56,6 +56,7 @@ export interface UseQuestionnaireStoreType {
   processedValueSetCodings: Record<string, Coding[]>;
   processedValueSetUrls: Record<string, string>;
   cachedValueSetCodings: Record<string, Coding[]>;
+  fhirPathContext: Record<string, any>;
   buildSourceQuestionnaire: (
     questionnaire: Questionnaire,
     questionnaireResponse?: QuestionnaireResponse,
@@ -91,6 +92,7 @@ const useQuestionnaireStore = create<UseQuestionnaireStoreType>()((set, get) =>
   processedValueSetCodings: {},
   processedValueSetUrls: {},
   cachedValueSetCodings: {},
+  fhirPathContext: {},
   buildSourceQuestionnaire: async (
     questionnaire,
     questionnaireResponse = cloneDeep(emptyResponse),
@@ -108,14 +110,16 @@ const useQuestionnaireStore = create<UseQuestionnaireStoreType>()((set, get) =>
       initialEnableWhenLinkedQuestions,
       initialEnableWhenExpressions,
       initialCalculatedExpressions,
-      firstVisibleTab
+      firstVisibleTab,
+      updatedFhirPathContext
     } = initialiseFormFromResponse({
       questionnaireResponse,
       enableWhenItems: questionnaireModel.enableWhenItems,
       enableWhenExpressions: questionnaireModel.enableWhenExpressions,
       calculatedExpressions: questionnaireModel.calculatedExpressions,
       variablesFhirPath: questionnaireModel.variables.fhirPathVariables,
-      tabs: questionnaireModel.tabs
+      tabs: questionnaireModel.tabs,
+      fhirPathContext: questionnaireModel.fhirPathContext
     });
 
     set({
@@ -131,7 +135,8 @@ const useQuestionnaireStore = create<UseQuestionnaireStoreType>()((set, get) =>
       calculatedExpressions: initialCalculatedExpressions,
       answerExpressions: questionnaireModel.answerExpressions,
       processedValueSetCodings: questionnaireModel.processedValueSetCodings,
-      processedValueSetUrls: questionnaireModel.processedValueSetUrls
+      processedValueSetUrls: questionnaireModel.processedValueSetUrls,
+      fhirPathContext: updatedFhirPathContext
     });
   },
   destroySourceQuestionnaire: () =>
@@ -148,7 +153,8 @@ const useQuestionnaireStore = create<UseQuestionnaireStoreType>()((set, get) =>
       calculatedExpressions: {},
       answerExpressions: {},
       processedValueSetCodings: {},
-      processedValueSetUrls: {}
+      processedValueSetUrls: {},
+      fhirPathContext: {}
     }),
   switchTab: (newTabIndex: number) => set(() => ({ currentTabIndex: newTabIndex })),
   markTabAsComplete: (tabLinkId: string) => {
@@ -182,20 +188,31 @@ const useQuestionnaireStore = create<UseQuestionnaireStoreType>()((set, get) =>
   toggleEnableWhenActivation: (isActivated: boolean) =>
     set(() => ({ enableWhenIsActivated: isActivated })),
   updateExpressions: (updatedResponse: QuestionnaireResponse) => {
-    const { isUpdated, updatedCalculatedExpressions, updatedEnableWhenExpressions } =
-      evaluateUpdatedExpressions({
-        updatedResponse: updatedResponse,
-        enableWhenExpressions: get().enableWhenExpressions,
-        calculatedExpressions: get().calculatedExpressions,
-        variablesFhirPath: get().variables.fhirPathVariables
-      });
+    const {
+      isUpdated,
+      updatedEnableWhenExpressions,
+      updatedCalculatedExpressions,
+      updatedFhirPathContext
+    } = evaluateUpdatedExpressions({
+      updatedResponse,
+      enableWhenExpressions: get().enableWhenExpressions,
+      calculatedExpressions: get().calculatedExpressions,
+      variablesFhirPath: get().variables.fhirPathVariables,
+      existingFhirPathContext: get().fhirPathContext
+    });
 
     if (isUpdated) {
       set(() => ({
         enableWhenExpressions: updatedEnableWhenExpressions,
-        calculatedExpressions: updatedCalculatedExpressions
+        calculatedExpressions: updatedCalculatedExpressions,
+        fhirPathContext: updatedFhirPathContext
       }));
+      return 0;
     }
+
+    set(() => ({
+      fhirPathContext: updatedFhirPathContext
+    }));
   },
   addCodingToCache: (valueSetUrl: string, codings: Coding[]) =>
     set(() => ({
@@ -205,11 +222,14 @@ const useQuestionnaireStore = create<UseQuestionnaireStoreType>()((set, get) =>
       }
     })),
   updatePopulatedProperties: (populatedResponse: QuestionnaireResponse, persistTabIndex) => {
-    const initialCalculatedExpressions = evaluateInitialCalculatedExpressions({
+    const evaluateInitialCalculatedExpressionsResult = evaluateInitialCalculatedExpressions({
       initialResponse: populatedResponse,
       calculatedExpressions: get().calculatedExpressions,
-      variablesFhirPath: get().variables.fhirPathVariables
+      variablesFhirPath: get().variables.fhirPathVariables,
+      existingFhirPathContext: get().fhirPathContext
     });
+    const { initialCalculatedExpressions } = evaluateInitialCalculatedExpressionsResult;
+    let updatedFhirPathContext = evaluateInitialCalculatedExpressionsResult.updatedFhirPathContext;
 
     const updatedResponse = initialiseCalculatedExpressionValues(
       get().sourceQuestionnaire,
@@ -228,15 +248,18 @@ const useQuestionnaireStore = create<UseQuestionnaireStoreType>()((set, get) =>
       enableWhenExpressions: get().enableWhenExpressions,
       calculatedExpressions: initialCalculatedExpressions,
       variablesFhirPath: get().variables.fhirPathVariables,
-      tabs: get().tabs
+      tabs: get().tabs,
+      fhirPathContext: updatedFhirPathContext
     });
+    updatedFhirPathContext = evaluateInitialCalculatedExpressionsResult.updatedFhirPathContext;
 
     set(() => ({
       enableWhenItems: initialEnableWhenItems,
       enableWhenLinkedQuestions: initialEnableWhenLinkedQuestions,
       enableWhenExpressions: initialEnableWhenExpressions,
       calculatedExpressions: initialCalculatedExpressions,
-      currentTabIndex: persistTabIndex ? get().currentTabIndex : firstVisibleTab
+      currentTabIndex: persistTabIndex ? get().currentTabIndex : firstVisibleTab,
+      fhirPathContext: updatedFhirPathContext
     }));
 
     return updatedResponse;

package/src/theme/customGlobalStyles.tsx

@@ -39,7 +39,8 @@ export default function CustomGlobalStyles() {
         },
         '#root': {
           width: '100%',
-          height: '100%'
+          height: '100%',
+          textAlign: 'left'
         },
         input: {
           '&[type=number]': {
@@ -57,10 +58,6 @@ export default function CustomGlobalStyles() {
         img: {
           display: 'block',
           maxWidth: '100%'
-        },
-        ul: {
-          margin: 0,
-          padding: 0
         }
       }}
     />

package/src/theme/typography.ts

@@ -37,7 +37,7 @@ export function responsiveFontSizes(props: { sm: number; md: number; lg: number
 // ----------------------------------------------------------------------
 
 const typography = {
-  fontFamily: ['Inter', 'sans-serif', 'Roboto', 'Arial', '"Helvetica Neue"', 'Helvetica'].join(','),
+  fontFamily: ['Inter', 'sans-serif', 'Helvetica', 'Arial', 'Roboto', '"Helvetica Neue"'].join(','),
   fontWeightRegular: 500,
   h1: {
     fontWeight: 800,
@@ -72,40 +72,40 @@ const typography = {
   h6: {
     fontWeight: 700,
     lineHeight: 28 / 18,
-    fontSize: pxToRem(13),
+    fontSize: pxToRem(13.5),
     ...responsiveFontSizes({ sm: 14, md: 14, lg: 14 })
   },
   subtitle1: {
     fontWeight: 600,
     lineHeight: 1.5,
-    fontSize: pxToRem(13)
+    fontSize: pxToRem(13.5)
   },
   subtitle2: {
     fontWeight: 600,
     lineHeight: 22 / 14,
-    fontSize: pxToRem(11.5)
+    fontSize: pxToRem(12)
   },
   body1: {
     lineHeight: 1.5,
-    fontSize: pxToRem(12.25)
+    fontSize: pxToRem(13)
   },
   body2: {
     lineHeight: 22 / 14,
-    fontSize: pxToRem(11)
+    fontSize: pxToRem(11.5)
   },
   caption: {
     lineHeight: 1.5,
-    fontSize: pxToRem(10)
+    fontSize: pxToRem(10.5)
   },
   overline: {
     fontWeight: 700,
     lineHeight: 1.5,
-    fontSize: pxToRem(10)
+    fontSize: pxToRem(10.5)
   },
   button: {
     fontWeight: 700,
     lineHeight: 24 / 14,
-    fontSize: pxToRem(12)
+    fontSize: pxToRem(12.5)
   }
 };
 

package/src/utils/calculatedExpression.ts

@@ -40,49 +40,62 @@ interface EvaluateInitialCalculatedExpressionsParams {
   initialResponse: QuestionnaireResponse;
   calculatedExpressions: Record<string, CalculatedExpression>;
   variablesFhirPath: Record<string, Expression[]>;
+  existingFhirPathContext: Record<string, any>;
 }
 
 export function evaluateInitialCalculatedExpressions(
   params: EvaluateInitialCalculatedExpressionsParams
-): Record<string, CalculatedExpression> {
-  const { initialResponse, calculatedExpressions, variablesFhirPath } = params;
+): {
+  initialCalculatedExpressions: Record<string, CalculatedExpression>;
+  updatedFhirPathContext: Record<string, any>;
+} {
+  const { initialResponse, calculatedExpressions, variablesFhirPath, existingFhirPathContext } =
+    params;
 
-  // Return early if initialResponse is empty
-  if (_isEqual(initialResponse, cloneDeep(emptyResponse))) {
-    return calculatedExpressions;
+  // Return early if initialResponse is empty or there are no calculated expressions to evaluate
+  if (
+    _isEqual(initialResponse, cloneDeep(emptyResponse)) ||
+    Object.keys(calculatedExpressions).length === 0
+  ) {
+    return {
+      initialCalculatedExpressions: calculatedExpressions,
+      updatedFhirPathContext: existingFhirPathContext
+    };
   }
 
   const initialCalculatedExpressions: Record<string, CalculatedExpression> = {
     ...calculatedExpressions
   };
+  const updatedFhirPathContext = createFhirPathContext(
+    initialResponse,
+    variablesFhirPath,
+    existingFhirPathContext
+  );
 
-  if (Object.keys(initialCalculatedExpressions).length > 0) {
-    const fhirPathContext: Record<string, any> = createFhirPathContext(
-      initialResponse,
-      variablesFhirPath
-    );
-
-    for (const linkId in initialCalculatedExpressions) {
-      try {
-        const result = fhirpath.evaluate(
-          initialResponse,
-          calculatedExpressions[linkId].expression,
-          fhirPathContext,
-          fhirpath_r4_model
-        );
+  for (const linkId in initialCalculatedExpressions) {
+    try {
+      const result = fhirpath.evaluate(
+        initialResponse,
+        calculatedExpressions[linkId].expression,
+        updatedFhirPathContext,
+        fhirpath_r4_model
+      );
 
-        if (!_isEqual(calculatedExpressions[linkId].value, result[0])) {
-          initialCalculatedExpressions[linkId].value = result[0];
-        }
-      } catch (e) {
-        console.warn(
-          e.message,
-          `LinkId: ${linkId}\nExpression: ${calculatedExpressions[linkId].expression}`
-        );
+      if (!_isEqual(calculatedExpressions[linkId].value, result[0])) {
+        initialCalculatedExpressions[linkId].value = result[0];
       }
+    } catch (e) {
+      console.warn(
+        e.message,
+        `LinkId: ${linkId}\nExpression: ${calculatedExpressions[linkId].expression}`
+      );
     }
   }
-  return initialCalculatedExpressions;
+
+  return {
+    initialCalculatedExpressions,
+    updatedFhirPathContext
+  };
 }
 
 export function evaluateCalculatedExpressions(

package/src/utils/dayjsExtend.ts

@@ -0,0 +1,23 @@
+/*
+ * Copyright 2023 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 dayjs from 'dayjs';
+import localizedFormat from 'dayjs/plugin/localizedFormat';
+import customParseFormat from 'dayjs/plugin/customParseFormat';
+
+dayjs.extend(localizedFormat);
+dayjs.extend(customParseFormat);

package/src/utils/enableWhenExpression.ts

@@ -28,52 +28,67 @@ interface EvaluateInitialEnableWhenExpressionsParams {
   initialResponse: QuestionnaireResponse;
   enableWhenExpressions: Record<string, EnableWhenExpression>;
   variablesFhirPath: Record<string, Expression[]>;
+  existingFhirPathContext: Record<string, any>;
 }
 
 export function evaluateInitialEnableWhenExpressions(
   params: EvaluateInitialEnableWhenExpressionsParams
-): Record<string, EnableWhenExpression> {
-  const { initialResponse, enableWhenExpressions, variablesFhirPath } = params;
+): {
+  initialEnableWhenExpressions: Record<string, EnableWhenExpression>;
+  updatedFhirPathContext: Record<string, any>;
+} {
+  const { initialResponse, enableWhenExpressions, variablesFhirPath, existingFhirPathContext } =
+    params;
 
-  // Return early if initialResponse is empty
-  if (_isEqual(initialResponse, cloneDeep(emptyResponse))) {
-    return enableWhenExpressions;
+  // Return early if initialResponse is empty or there are no enableWhen expressions to evaluate
+  if (
+    _isEqual(initialResponse, cloneDeep(emptyResponse)) ||
+    Object.keys(enableWhenExpressions).length === 0
+  ) {
+    return {
+      initialEnableWhenExpressions: enableWhenExpressions,
+      updatedFhirPathContext: existingFhirPathContext
+    };
   }
 
-  const initialExpressions: Record<string, EnableWhenExpression> = { ...enableWhenExpressions };
-
-  if (Object.keys(initialExpressions).length > 0) {
-    const fhirPathContext: Record<string, any> = createFhirPathContext(
-      initialResponse,
-      variablesFhirPath
-    );
+  const initialEnableWhenExpressions: Record<string, EnableWhenExpression> = {
+    ...enableWhenExpressions
+  };
+  const updatedFhirPathContext = createFhirPathContext(
+    initialResponse,
+    variablesFhirPath,
+    existingFhirPathContext
+  );
 
-    for (const linkId in initialExpressions) {
-      try {
-        const result = fhirpath.evaluate(
-          initialResponse,
-          enableWhenExpressions[linkId].expression,
-          fhirPathContext,
-          fhirpath_r4_model
-        );
+  for (const linkId in initialEnableWhenExpressions) {
+    try {
+      const result = fhirpath.evaluate(
+        initialResponse,
+        enableWhenExpressions[linkId].expression,
+        updatedFhirPathContext,
+        fhirpath_r4_model
+      );
 
-        if (result.length > 0) {
-          initialExpressions[linkId].isEnabled = result[0];
-        }
+      if (result.length > 0) {
+        initialEnableWhenExpressions[linkId].isEnabled = result[0];
+      }
 
-        // handle intersect edge case - evualate() returns empty array if result is false
-        if (enableWhenExpressions[linkId].expression.includes('intersect') && result.length === 0) {
-          initialExpressions[linkId].isEnabled = false;
-        }
-      } catch (e) {
-        console.warn(
-          e.message,
-          `LinkId: ${linkId}\nExpression: ${enableWhenExpressions[linkId].expression}`
-        );
+      // handle intersect edge case - evaluate() returns empty array if result is false
+      if (enableWhenExpressions[linkId].expression.includes('intersect') && result.length === 0) {
+        initialEnableWhenExpressions[linkId].isEnabled = false;
       }
+    } catch (e) {
+      console.warn(
+        e.message,
+        `LinkId: ${linkId}\nExpression: ${enableWhenExpressions[linkId].expression}`
+      );
     }
   }
-  return initialExpressions;
+
+  return {
+    initialEnableWhenExpressions,
+    updatedFhirPathContext
+  };
 }
 
 export function evaluateEnableWhenExpressions(
@@ -104,7 +119,7 @@ export function evaluateEnableWhenExpressions(
         }
       }
 
-      // handle intersect edge case - evualate() returns empty array if result is false
+      // handle intersect edge case - evaluate() returns empty array if result is false
       if (enableWhenExpressions[linkId].expression.includes('intersect') && result.length === 0) {
         updatedEnableWhenExpressions[linkId].isEnabled = false;
       }