@aehrc/smart-forms-renderer 0.25.2 → 0.26.1

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/index.ts

@@ -22,3 +22,4 @@ export {
   readInitialAnswers,
   setInitialAnswers
 } from './enableWhen';
+export { initialiseQuestionnaireResponse } from './initialise';

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];
+  }
+}