@aehrc/smart-forms-renderer 0.8.0 → 0.9.0

package/src/utils/calculatedExpression.ts

@@ -22,6 +22,7 @@ import type {
   Expression,
   Questionnaire,
   QuestionnaireItem,
+  QuestionnaireItemAnswerOption,
   QuestionnaireResponse,
   QuestionnaireResponseItem,
   QuestionnaireResponseItemAnswer
@@ -32,52 +33,69 @@ import { createFhirPathContext } from './fhirpath';
 import { getQrItemsIndex, mapQItemsIndex } from './mapItem';
 import { updateQrItemsInGroup } from './qrItem';
 import cloneDeep from 'lodash.clonedeep';
+import dayjs from 'dayjs';
+import moment from 'moment';
 
 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 initialExpressions: Record<string, CalculatedExpression> = { ...calculatedExpressions };
-
-  if (Object.keys(initialExpressions).length > 0) {
-    const fhirPathContext: Record<string, any> = createFhirPathContext(
-      initialResponse,
-      variablesFhirPath
-    );
+  const initialCalculatedExpressions: Record<string, CalculatedExpression> = {
+    ...calculatedExpressions
+  };
+  const updatedFhirPathContext = createFhirPathContext(
+    initialResponse,
+    variablesFhirPath,
+    existingFhirPathContext
+  );
 
-    for (const linkId in initialExpressions) {
-      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 (calculatedExpressions[linkId].value !== result[0]) {
-          initialExpressions[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 initialExpressions;
+
+  return {
+    initialCalculatedExpressions,
+    updatedFhirPathContext
+  };
 }
 
 export function evaluateCalculatedExpressions(
@@ -102,7 +120,7 @@ export function evaluateCalculatedExpressions(
       );
 
       if (result.length > 0) {
-        if (calculatedExpressions[linkId].value !== result[0]) {
+        if (!_isEqual(calculatedExpressions[linkId].value, result[0])) {
           isUpdated = true;
           updatedCalculatedExpressions[linkId].value = result[0];
         }
@@ -283,17 +301,68 @@ function constructSingleItem(
   };
 }
 
-function parseValueToAnswer(
-  qItem: QuestionnaireItem,
-  value: string | number
-): QuestionnaireResponseItemAnswer {
+// duplicate functions in sdc-populate
+function parseValueToAnswer(qItem: QuestionnaireItem, value: any): QuestionnaireResponseItemAnswer {
+  if (qItem.answerOption) {
+    const answerOption = qItem.answerOption.find(
+      (option: QuestionnaireItemAnswerOption) => option.valueCoding?.code === value?.code
+    );
+
+    if (answerOption) {
+      return answerOption;
+    }
+  }
+
+  if (typeof value === 'boolean' && qItem.type === 'boolean') {
+    return { valueBoolean: value };
+  }
+
   if (typeof value === 'number') {
+    if (qItem.type === 'decimal') {
+      return { valueDecimal: value };
+    }
     if (qItem.type === 'integer') {
       return { valueInteger: value };
     }
+  }
+
+  if (typeof value === 'object') {
+    return { valueCoding: value };
+  }
 
-    return { valueDecimal: value };
+  // Value is string at this point
+  if (qItem.type === 'date' && checkIsDateTime(value)) {
+    return { valueDate: value };
+  }
+
+  if (qItem.type === 'dateTime' && checkIsDateTime(value)) {
+    return { valueDateTime: value };
+  }
+
+  if (qItem.type === 'time' && checkIsTime(value)) {
+    return { valueTime: value };
   }
 
   return { valueString: value };
 }
+
+/**
+ * Check if an answer is a datetime in the format YYYY, YYYY-MM, YYYY-MM-DD, YYYY-MM-DDThh:mm:ss+zz:zz
+ *
+ * @author Sean Fong
+ */
+export function checkIsDateTime(value: string): boolean {
+  const acceptedFormats = ['YYYY', 'YYYY-MM', 'YYYY-MM-DD', 'YYYY-MM-DDTHH:mm:ssZ'];
+  const formattedDate = dayjs(value).format();
+  return moment(formattedDate, acceptedFormats, true).isValid();
+}
+
+/**
+ * Check if an answer is in a  time format - Regex: ([01][0-9]|2[0-3]):[0-5][0-9]:([0-5][0-9]|60)(\.[0-9]+)?
+ *
+ * @author Sean Fong
+ */
+export function checkIsTime(value: string): boolean {
+  const timeRegex = /^([01][0-9]|2[0-3]):[0-5][0-9]:([0-5][0-9]|60)(\.[0-9]+)?$/;
+  return timeRegex.test(value);
+}

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

package/src/utils/fhirpath.ts

@@ -28,53 +28,72 @@ interface EvaluateUpdatedExpressionsParams {
   calculatedExpressions: Record<string, CalculatedExpression>;
   enableWhenExpressions: Record<string, EnableWhenExpression>;
   variablesFhirPath: Record<string, Expression[]>;
+  existingFhirPathContext: Record<string, any>;
 }
 
 export function evaluateUpdatedExpressions(params: EvaluateUpdatedExpressionsParams): {
   isUpdated: boolean;
   updatedEnableWhenExpressions: Record<string, EnableWhenExpression>;
   updatedCalculatedExpressions: Record<string, CalculatedExpression>;
+  updatedFhirPathContext: Record<string, any>;
 } {
-  const { updatedResponse, enableWhenExpressions, calculatedExpressions, variablesFhirPath } =
-    params;
-
-  const hasExpressionToBeUpdated =
-    Object.keys(enableWhenExpressions).length > 0 || Object.keys(calculatedExpressions).length > 0;
-  if (hasExpressionToBeUpdated && updatedResponse.item) {
-    const fhirPathContext: Record<string, any> = createFhirPathContext(
-      updatedResponse,
-      variablesFhirPath
-    );
-
-    // Update enableWhenExpressions
-    const { enableWhenExpsIsUpdated, updatedEnableWhenExpressions } = evaluateEnableWhenExpressions(
-      fhirPathContext,
-      enableWhenExpressions
-    );
-
-    // Update calculatedExpressions
-    const { calculatedExpsIsUpdated, updatedCalculatedExpressions } = evaluateCalculatedExpressions(
-      fhirPathContext,
-      calculatedExpressions
-    );
-
-    const isUpdated = enableWhenExpsIsUpdated || calculatedExpsIsUpdated;
-
-    return { isUpdated, updatedEnableWhenExpressions, updatedCalculatedExpressions };
+  const {
+    updatedResponse,
+    enableWhenExpressions,
+    calculatedExpressions,
+    variablesFhirPath,
+    existingFhirPathContext
+  } = params;
+
+  const noExpressionsToBeUpdated =
+    Object.keys(enableWhenExpressions).length === 0 &&
+    Object.keys(calculatedExpressions).length === 0;
+  if (noExpressionsToBeUpdated || !updatedResponse.item) {
+    return {
+      isUpdated: false,
+      updatedEnableWhenExpressions: enableWhenExpressions,
+      updatedCalculatedExpressions: calculatedExpressions,
+      updatedFhirPathContext: existingFhirPathContext
+    };
   }
 
+  const updatedFhirPathContext = createFhirPathContext(
+    updatedResponse,
+    variablesFhirPath,
+    existingFhirPathContext
+  );
+
+  // Update enableWhenExpressions
+  const { enableWhenExpsIsUpdated, updatedEnableWhenExpressions } = evaluateEnableWhenExpressions(
+    updatedFhirPathContext,
+    enableWhenExpressions
+  );
+
+  // Update calculatedExpressions
+  const { calculatedExpsIsUpdated, updatedCalculatedExpressions } = evaluateCalculatedExpressions(
+    updatedFhirPathContext,
+    calculatedExpressions
+  );
+
+  const isUpdated = enableWhenExpsIsUpdated || calculatedExpsIsUpdated;
+
   return {
-    isUpdated: false,
-    updatedEnableWhenExpressions: enableWhenExpressions,
-    updatedCalculatedExpressions: calculatedExpressions
+    isUpdated,
+    updatedEnableWhenExpressions,
+    updatedCalculatedExpressions,
+    updatedFhirPathContext
   };
 }
 
 export function createFhirPathContext(
   questionnaireResponse: QuestionnaireResponse,
-  variablesFhirPath: Record<string, Expression[]>
+  variablesFhirPath: Record<string, Expression[]>,
+  existingFhirPathContext: Record<string, any>
 ): Record<string, any> {
-  const fhirPathContext: Record<string, any> = { resource: questionnaireResponse };
+  let fhirPathContext: Record<string, any> = { resource: questionnaireResponse };
+  if (Object.keys(existingFhirPathContext).length > 0) {
+    fhirPathContext = { ...fhirPathContext, ...existingFhirPathContext };
+  }
 
   if (!questionnaireResponse.item || questionnaireResponse.item.length === 0) {
     return fhirPathContext;

package/src/utils/index.ts

@@ -16,3 +16,4 @@
  */
 
 export { isSpecificItemControl } from './itemControl';
+export { isRepeatItemAndNotCheckbox, isHidden } from './qItem';

package/src/utils/initialiseForm.ts

@@ -31,6 +31,7 @@ interface initialFormFromResponseParams {
   calculatedExpressions: Record<string, CalculatedExpression>;
   variablesFhirPath: Record<string, Expression[]>;
   tabs: Tabs;
+  fhirPathContext: Record<string, any>;
 }
 
 export function initialiseFormFromResponse(params: initialFormFromResponseParams): {
@@ -39,6 +40,7 @@ export function initialiseFormFromResponse(params: initialFormFromResponseParams
   initialEnableWhenExpressions: Record<string, EnableWhenExpression>;
   initialCalculatedExpressions: Record<string, CalculatedExpression>;
   firstVisibleTab: number;
+  updatedFhirPathContext: Record<string, any>;
 } {
   const {
     questionnaireResponse,
@@ -48,23 +50,30 @@ export function initialiseFormFromResponse(params: initialFormFromResponseParams
     variablesFhirPath,
     tabs
   } = params;
+  let updatedFhirPathContext = params.fhirPathContext;
 
   const { initialisedItems, linkedQuestions } = assignPopulatedAnswersToEnableWhen(
     enableWhenItems,
     questionnaireResponse
   );
 
-  const initialEnableWhenExpressions = evaluateInitialEnableWhenExpressions({
+  const evaluateInitialEnableWhenExpressionsResult = evaluateInitialEnableWhenExpressions({
     initialResponse: questionnaireResponse,
     enableWhenExpressions: enableWhenExpressions,
-    variablesFhirPath: variablesFhirPath
+    variablesFhirPath: variablesFhirPath,
+    existingFhirPathContext: updatedFhirPathContext
   });
+  const { initialEnableWhenExpressions } = evaluateInitialEnableWhenExpressionsResult;
+  updatedFhirPathContext = evaluateInitialEnableWhenExpressionsResult.updatedFhirPathContext;
 
-  const initialCalculatedExpressions = evaluateInitialCalculatedExpressions({
+  const evaluateInitialCalculatedExpressionsResult = evaluateInitialCalculatedExpressions({
     initialResponse: questionnaireResponse,
     calculatedExpressions: calculatedExpressions,
-    variablesFhirPath: variablesFhirPath
+    variablesFhirPath: variablesFhirPath,
+    existingFhirPathContext: updatedFhirPathContext
   });
+  const { initialCalculatedExpressions } = evaluateInitialCalculatedExpressionsResult;
+  updatedFhirPathContext = evaluateInitialEnableWhenExpressionsResult.updatedFhirPathContext;
 
   const firstVisibleTab =
     Object.keys(tabs).length > 0
@@ -76,6 +85,7 @@ export function initialiseFormFromResponse(params: initialFormFromResponseParams
     initialEnableWhenLinkedQuestions: linkedQuestions,
     initialEnableWhenExpressions,
     initialCalculatedExpressions,
-    firstVisibleTab
+    firstVisibleTab,
+    updatedFhirPathContext
   };
 }

package/src/utils/itemControl.ts

@@ -284,6 +284,38 @@ export function getTextDisplayUnit(qItem: QuestionnaireItem): string {
   return '';
 }
 
+/**
+ * Get text display lower bound for items with itemControlCode "lower" and has a "lower" childItem
+ *
+ * @author Sean Fong
+ */
+export function getTextDisplayLower(qItem: QuestionnaireItem): string {
+  if (qItem.item) {
+    for (const childItem of qItem.item) {
+      if (childItem.type === 'display' && isSpecificItemControl(childItem, 'lower')) {
+        return `${childItem.text}`;
+      }
+    }
+  }
+  return '';
+}
+
+/**
+ * Get text display upper bound for items with itemControlCode "upper" and has a "upper" childItem
+ *
+ * @author Sean Fong
+ */
+export function getTextDisplayUpper(qItem: QuestionnaireItem): string {
+  if (qItem.item) {
+    for (const childItem of qItem.item) {
+      if (childItem.type === 'display' && isSpecificItemControl(childItem, 'upper')) {
+        return `${childItem.text}`;
+      }
+    }
+  }
+  return '';
+}
+
 /**
  * Get text display instructions for items with itemControlCode instructions and has an instructions childItem
  *

package/src/utils/mapItem.ts

@@ -30,7 +30,7 @@ export function getQrItemsIndex(
   qItems: QuestionnaireItem[],
   qrItems: QuestionnaireResponseItem[],
   qItemsIndexMap: Record<string, number>
-): (QuestionnaireResponseItem | QuestionnaireResponseItem[])[] {
+): (QuestionnaireResponseItem | QuestionnaireResponseItem[] | undefined)[] {
   // Generate a <linkId, QrItem OR QrItems> dictionary
   const qrItemsCollected: Record<string, QuestionnaireResponseItem | QuestionnaireResponseItem[]> =
     {};

package/src/utils/qrItem.ts

@@ -94,7 +94,7 @@ export function removeNoAnswerQrItem(
  *
  * @author Sean Fong
  */
-export function createQrGroup(qItem: QuestionnaireItem): QuestionnaireResponseItem {
+export function createEmptyQrGroup(qItem: QuestionnaireItem): QuestionnaireResponseItem {
   return {
     linkId: qItem.linkId,
     text: qItem.text,
@@ -114,21 +114,6 @@ export function createEmptyQrItem(qItem: QuestionnaireItem): QuestionnaireRespon
   };
 }
 
-/**
- * Create an empty qrItem from a given qItem with its display unit
- *
- * @author Sean Fong
- */
-export function createEmptyQrItemWithUnit(
-  qItem: QuestionnaireItem,
-  unit: string
-): QuestionnaireResponseItem {
-  return {
-    linkId: qItem.linkId,
-    text: unit !== '' ? `${qItem.text} (${unit})` : qItem.text
-  };
-}
-
 /**
  * Updates the QuestionnaireResponseItem group by adding/removing a new/modified child QuestionnaireResponseItem into/from a qrGroup
  * Takes either a single newQrItem or an array of newQrItems

package/src/utils/questionnaireStoreUtils/createQuestionaireModel.ts

@@ -86,7 +86,8 @@ export async function createQuestionnaireModel(
     calculatedExpressions,
     answerExpressions,
     processedValueSetCodings,
-    processedValueSetUrls
+    processedValueSetUrls,
+    fhirPathContext: {}
   };
 }
 
@@ -101,6 +102,7 @@ function createEmptyModel(): QuestionnaireModel {
     answerExpressions: {},
     enableWhenItems: {},
     processedValueSetCodings: {},
-    processedValueSetUrls: {}
+    processedValueSetUrls: {},
+    fhirPathContext: {}
   };
 }

package/src/utils/removeHidden.ts

@@ -100,8 +100,9 @@ function readQuestionnaireResponseItemRecursive(
         enableWhenItems,
         enableWhenExpressions
       })
-    )
+    ) {
       return null;
+    }
 
     if (qrItems && qrItems.length > 0) {
       const newQrItems: QuestionnaireResponseItem[] = [];