@aehrc/smart-forms-renderer 0.17.0 → 0.19.0

package/src/utils/enableWhen.ts

@@ -23,7 +23,11 @@ import type {
   QuestionnaireResponseItemAnswer
 } from 'fhir/r4';
 import cloneDeep from 'lodash.clonedeep';
-import type { EnableWhenItemProperties, EnableWhenItems } from '../interfaces/enableWhen.interface';
+import type {
+  EnableWhenItems,
+  EnableWhenRepeatItemProperties,
+  EnableWhenSingleItemProperties
+} from '../interfaces';
 
 /**
  * Create a linkedQuestionsMap that contains linked items of enableWhen items
@@ -35,18 +39,23 @@ import type { EnableWhenItemProperties, EnableWhenItems } from '../interfaces/en
 export function createEnableWhenLinkedQuestions(enableWhenItems: EnableWhenItems) {
   const linkedQuestionsMap: Record<string, string[]> = {};
 
-  for (const linkId in enableWhenItems) {
-    enableWhenItems[linkId].linked.forEach((linkedItem) => {
-      const linkQId = linkedItem.enableWhen.question;
-      if (!linkedQuestionsMap[linkQId]) {
-        linkedQuestionsMap[linkQId] = [];
-      }
+  const { singleItems, repeatItems } = enableWhenItems;
 
-      if (!linkedQuestionsMap[linkQId].includes(linkId)) {
-        linkedQuestionsMap[linkQId].push(linkId);
-      }
-    });
+  for (const items of [singleItems, repeatItems]) {
+    for (const linkId in items) {
+      items[linkId].linked.forEach((linkedItem) => {
+        const linkQId = linkedItem.enableWhen.question;
+        if (!linkedQuestionsMap[linkQId]) {
+          linkedQuestionsMap[linkQId] = [];
+        }
+
+        if (!linkedQuestionsMap[linkQId].includes(linkId)) {
+          linkedQuestionsMap[linkQId].push(linkId);
+        }
+      });
+    }
   }
+
   return linkedQuestionsMap;
 }
 
@@ -117,11 +126,11 @@ function answerOperatorSwitcher(
   value: boolean | string | number | Quantity | QuestionnaireResponseItemAnswer,
   operator: QuestionnaireItemEnableWhen['operator']
 ): boolean {
-  // FIXME runs even when the linked textbox is not changed
   switch (operator) {
-    case 'exists':
-      // check if value is an object and contains any answerValues
-      return typeof value === 'object' && Object.keys(value).length !== 0;
+    case 'exists': {
+      const answerExists = typeof value === 'object' && Object.keys(value).length !== 0;
+      return answerExists === expected;
+    }
     case '=':
       return value === expected;
     case '!=':
@@ -139,6 +148,36 @@ function answerOperatorSwitcher(
   }
 }
 
+export function mutateRepeatEnableWhenItemInstances(
+  items: EnableWhenItems,
+  parentRepeatGroupLinkId: string,
+  parentRepeatGroupIndex: number,
+  actionType: 'add' | 'remove'
+): EnableWhenItems {
+  const { repeatItems } = items;
+
+  for (const linkId in repeatItems) {
+    for (const linkedItem of repeatItems[linkId].linked) {
+      if (linkedItem.parentLinkId !== parentRepeatGroupLinkId) {
+        continue;
+      }
+
+      if (actionType === 'add') {
+        linkedItem.answers.splice(parentRepeatGroupIndex, 0);
+        repeatItems[linkId].enabledIndexes[parentRepeatGroupIndex] = checkItemIsEnabledRepeat(
+          repeatItems[linkId],
+          parentRepeatGroupIndex
+        );
+      } else if (actionType === 'remove') {
+        linkedItem.answers.splice(parentRepeatGroupIndex, 1);
+        repeatItems[linkId].enabledIndexes.splice(parentRepeatGroupIndex, 1);
+      }
+    }
+  }
+
+  return items;
+}
+
 /**
  * Read initial answer values in questionnaireResponse
  * return a map of initial values with key-value pair <linkedItemId, initial value>
@@ -203,7 +242,13 @@ export function setInitialAnswers(
       const linkedQuestions = linkedQuestionsMap[linkId];
       const newAnswer = initialAnswers[linkId];
 
-      updatedItems = updateItemAnswer(updatedItems, linkedQuestions, linkId, newAnswer);
+      updatedItems = updateEnableWhenItemAnswer(
+        updatedItems,
+        linkedQuestions,
+        linkId,
+        newAnswer,
+        null
+      );
     }
   }
   return updatedItems;
@@ -215,35 +260,65 @@ export function setInitialAnswers(
  *
  * @author Sean Fong
  */
-export function updateItemAnswer(
+export function updateEnableWhenItemAnswer(
   items: EnableWhenItems,
   linkedQuestions: string[],
   linkId: string,
-  newAnswer: QuestionnaireResponseItemAnswer[]
+  newAnswer: QuestionnaireResponseItemAnswer[] | undefined,
+  parentRepeatGroupIndex: number | null
 ): EnableWhenItems {
-  linkedQuestions.forEach((question) => {
-    // Update modified linked answer
-    items[question].linked.forEach((linkedItem) => {
-      if (linkedItem.enableWhen.question === linkId) {
-        linkedItem.answer = newAnswer ?? undefined;
-      }
-    });
+  const { singleItems, repeatItems } = items;
+
+  for (const linkedQuestion of linkedQuestions) {
+    // Linked question is in single items
+    if (singleItems[linkedQuestion]) {
+      // Update modified linked answer
+      singleItems[linkedQuestion].linked.forEach((linkedItem) => {
+        if (linkedItem.enableWhen.question === linkId) {
+          linkedItem.answer = newAnswer ?? undefined;
+        }
+      });
+
+      // Update enabled status of modified enableWhenItem
+      singleItems[linkedQuestion].isEnabled = checkItemIsEnabledSingle(singleItems[linkedQuestion]);
+      continue;
+    }
+
+    // Linked question is in repeat items
+    if (repeatItems[linkedQuestion] && parentRepeatGroupIndex !== null) {
+      // Update modified linked answer
+      repeatItems[linkedQuestion].linked.forEach((linkedItem) => {
+        if (linkedItem.enableWhen.question === linkId) {
+          if (newAnswer) {
+            linkedItem.answers[parentRepeatGroupIndex] = newAnswer[0] ?? undefined;
+          } else {
+            delete linkedItem.answers[parentRepeatGroupIndex];
+          }
+        }
+      });
+
+      // Update enabled status of modified enableWhenItem
+      repeatItems[linkedQuestion].enabledIndexes[parentRepeatGroupIndex] = checkItemIsEnabledRepeat(
+        repeatItems[linkedQuestion],
+        parentRepeatGroupIndex
+      );
+    }
+  }
 
-    // Update enabled status of modified enableWhenItem
-    items[question].isEnabled = checkItemIsEnabled(items[question]);
-  });
   return items;
 }
 
 /**
- * Check if an enableWhenItem is enabled based on the answer of its linked items
+ * Check if a single enableWhenItem is enabled based on the answer of its linked items
  *
  * @author Sean Fong
  */
-export function checkItemIsEnabled(enableWhenItemProperties: EnableWhenItemProperties): boolean {
+export function checkItemIsEnabledSingle(
+  enableWhenItemProperties: EnableWhenSingleItemProperties
+): boolean {
   const checkedIsEnabledItems: boolean[] = [];
 
-  enableWhenItemProperties.linked.forEach((linkedItem) => {
+  for (const linkedItem of enableWhenItemProperties.linked) {
     if (linkedItem.answer && linkedItem.answer.length > 0) {
       for (const answer of linkedItem.answer) {
         const isEnabledForThisLinkedItem = isEnabledAnswerTypeSwitcher(
@@ -257,16 +332,60 @@ export function checkItemIsEnabled(enableWhenItemProperties: EnableWhenItemPrope
           break;
         }
       }
+      continue;
     }
-  });
+
+    // Linked item doesn't have any answers, but we still have to check for unanswered booleans
+    if (evaluateNonExistentAnswers(linkedItem.enableWhen)) {
+      checkedIsEnabledItems.push(true);
+    }
+  }
+
+  if (checkedIsEnabledItems.length === 0) {
+    return false;
+  }
+
+  return evaluateEnableBehaviour(checkedIsEnabledItems, enableWhenItemProperties.enableBehavior);
+}
+
+/**
+ * Check if a repeat enableWhenItem is enabled based on the answer of its linked items
+ *
+ * @author Sean Fong
+ */
+export function checkItemIsEnabledRepeat(
+  enableWhenItemProperties: EnableWhenRepeatItemProperties,
+  parentRepeatGroupIndex: number
+): boolean {
+  const checkedIsEnabledItems: boolean[] = [];
+
+  for (const linkedItem of enableWhenItemProperties.linked) {
+    const linkedAnswer = linkedItem.answers[parentRepeatGroupIndex];
+    if (linkedAnswer) {
+      const isEnabledForThisLinkedItem = isEnabledAnswerTypeSwitcher(
+        linkedItem.enableWhen,
+        linkedAnswer
+      );
+
+      if (isEnabledForThisLinkedItem) {
+        checkedIsEnabledItems.push(
+          isEnabledAnswerTypeSwitcher(linkedItem.enableWhen, linkedAnswer)
+        );
+      }
+      continue;
+    }
+
+    // Linked item doesn't have any answers, but we still have to check for unanswered booleans
+    if (evaluateNonExistentAnswers(linkedItem.enableWhen)) {
+      checkedIsEnabledItems.push(true);
+    }
+  }
 
   if (checkedIsEnabledItems.length === 0) {
     return false;
   }
 
-  return enableWhenItemProperties.enableBehavior === 'any'
-    ? checkedIsEnabledItems.some((isEnabled) => isEnabled)
-    : checkedIsEnabledItems.every((isEnabled) => isEnabled);
+  return evaluateEnableBehaviour(checkedIsEnabledItems, enableWhenItemProperties.enableBehavior);
 }
 
 export function assignPopulatedAnswersToEnableWhen(
@@ -275,7 +394,7 @@ export function assignPopulatedAnswersToEnableWhen(
 ): { initialisedItems: EnableWhenItems; linkedQuestions: Record<string, string[]> } {
   const linkedQuestions = createEnableWhenLinkedQuestions(items);
   const initialAnswers = readInitialAnswers(questionnaireResponse, linkedQuestions);
-  items = initialiseBooleanFalses(items);
+  items = initialiseUnansweredBooleans(items);
 
   const initialisedItems =
     Object.keys(initialAnswers).length > 0
@@ -285,30 +404,50 @@ export function assignPopulatedAnswersToEnableWhen(
   return { initialisedItems, linkedQuestions };
 }
 
-function initialiseBooleanFalses(items: EnableWhenItems): EnableWhenItems {
-  for (const linkId in items) {
-    const checkedIsEnabledItems: boolean[] = [];
-    const enableWhenItemProperties = items[linkId];
+function initialiseUnansweredBooleans(items: EnableWhenItems): EnableWhenItems {
+  const { singleItems, repeatItems } = items;
 
-    for (const linkedItem of enableWhenItemProperties.linked) {
-      if (linkedItem.enableWhen.answerBoolean === true && linkedItem.enableWhen.operator === '!=') {
-        checkedIsEnabledItems.push(true);
-        continue;
-      }
+  // Initialise unanswered booleans for enableWhen single items
+  for (const linkId in singleItems) {
+    const checkedIsEnabledItems = singleItems[linkId].linked.map((linkedItem) =>
+      evaluateNonExistentAnswers(linkedItem.enableWhen)
+    );
 
-      if (linkedItem.enableWhen.answerBoolean === false && linkedItem.enableWhen.operator === '=') {
-        checkedIsEnabledItems.push(true);
-        continue;
-      }
+    singleItems[linkId].isEnabled = evaluateEnableBehaviour(
+      checkedIsEnabledItems,
+      singleItems[linkId].enableBehavior
+    );
+  }
 
-      checkedIsEnabledItems.push(false);
-    }
+  // Initialise unanswered booleans for enableWhen repeat items
+  for (const linkId in repeatItems) {
+    const checkedIsEnabledItems = repeatItems[linkId].linked.map((linkedItem) =>
+      evaluateNonExistentAnswers(linkedItem.enableWhen)
+    );
 
-    enableWhenItemProperties.isEnabled =
-      enableWhenItemProperties.enableBehavior === 'any'
-        ? checkedIsEnabledItems.some((isEnabled) => isEnabled)
-        : checkedIsEnabledItems.every((isEnabled) => isEnabled);
+    const isEnabled = evaluateEnableBehaviour(
+      checkedIsEnabledItems,
+      repeatItems[linkId].enableBehavior
+    );
+    repeatItems[linkId].enabledIndexes = repeatItems[linkId].enabledIndexes.map(() => isEnabled);
   }
 
   return items;
 }
+
+// Internal functions
+function evaluateNonExistentAnswers(enableWhen: QuestionnaireItemEnableWhen) {
+  const unansweredBoolean =
+    typeof enableWhen.answerBoolean === 'boolean' && enableWhen.operator === '!=';
+  const unExistingAnswer = enableWhen.answerBoolean === false && enableWhen.operator === 'exists';
+  return unansweredBoolean || unExistingAnswer;
+}
+
+function evaluateEnableBehaviour(
+  isEnabledArr: boolean[],
+  enableBehavior: 'all' | 'any' | undefined
+) {
+  return enableBehavior === 'any'
+    ? isEnabledArr.some((isEnabled) => isEnabled)
+    : isEnabledArr.every((isEnabled) => isEnabled);
+}

package/src/utils/enableWhenExpression.ts

@@ -15,7 +15,7 @@
  * limitations under the License.
  */
 
-import type { EnableWhenExpression } from '../interfaces/enableWhen.interface';
+import type { EnableWhenExpression } from '../interfaces';
 import type { Expression, QuestionnaireResponse } from 'fhir/r4';
 import { createFhirPathContext } from './fhirpath';
 import fhirpath from 'fhirpath';
@@ -69,13 +69,14 @@ export function evaluateInitialEnableWhenExpressions(
         fhirpath_r4_model
       );
 
+      // Update enableWhenExpressions if length of result array > 0
       if (result.length > 0) {
-        initialEnableWhenExpressions[linkId].isEnabled = result[0];
+        updateEnableWhenExpressionStatus(initialEnableWhenExpressions, linkId, result);
       }
 
       // 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;
+        initialEnableWhenExpressions[linkId].isEnabledSingle = false;
       }
     } catch (e) {
       console.warn(
@@ -112,16 +113,14 @@ export function evaluateEnableWhenExpressions(
         fhirpath_r4_model
       );
 
+      // Update enableWhenExpressions if length of result array > 0
       if (result.length > 0) {
-        if (enableWhenExpressions[linkId].isEnabled !== result[0]) {
-          isUpdated = true;
-          updatedEnableWhenExpressions[linkId].isEnabled = result[0];
-        }
+        isUpdated = updateEnableWhenExpressionStatus(updatedEnableWhenExpressions, linkId, result);
       }
 
       // 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;
+        updatedEnableWhenExpressions[linkId].isEnabledSingle = false;
       }
     } catch (e) {
       console.warn(
@@ -136,3 +135,31 @@ export function evaluateEnableWhenExpressions(
     updatedEnableWhenExpressions: updatedEnableWhenExpressions
   };
 }
+
+function updateEnableWhenExpressionStatus(
+  enableWhenExpressions: Record<string, EnableWhenExpression>,
+  linkId: string,
+  result: any[]
+): boolean {
+  // Values are not fully boolean, expression is invalid
+  const everyResultIsBoolean = result.every((r) => typeof r === 'boolean');
+  if (!everyResultIsBoolean) {
+    return false;
+  }
+
+  // If result has multiple values
+  if (result.length > 1) {
+    if (enableWhenExpressions[linkId].isEnabledMultiple !== result) {
+      enableWhenExpressions[linkId].isEnabledMultiple = result;
+      return true;
+    }
+  }
+
+  // If result has only one value
+  if (enableWhenExpressions[linkId].isEnabledSingle !== result[0]) {
+    enableWhenExpressions[linkId].isEnabledSingle = result[0];
+    return true;
+  }
+
+  return false;
+}

package/src/utils/index.ts

@@ -17,3 +17,8 @@
 
 export { isSpecificItemControl } from './itemControl';
 export { isRepeatItemAndNotCheckbox } from './qItem';
+export {
+  createEnableWhenLinkedQuestions,
+  readInitialAnswers,
+  setInitialAnswers
+} from './enableWhen';

package/src/utils/misc.ts

@@ -0,0 +1,160 @@
+/*
+ * 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.
+ */
+
+// TODO to be imported into sdc-fhir-helpers
+
+import type { Questionnaire, QuestionnaireItem } from 'fhir/r4';
+
+export function getQuestionnaireItem(
+  questionnaire: Questionnaire,
+  targetLinkId: string
+): QuestionnaireItem | null {
+  // Search through the top level items recursively
+  const topLevelQItems = questionnaire.item;
+  if (topLevelQItems) {
+    for (const topLevelQItem of topLevelQItems) {
+      const foundQItem = getQuestionnaireItemRecursive(topLevelQItem, targetLinkId);
+      if (foundQItem) {
+        return foundQItem;
+      }
+    }
+  }
+
+  // No matching item found in the questionnaire, return null
+  return null;
+}
+
+export function getQuestionnaireItemRecursive(
+  qItem: QuestionnaireItem,
+  targetLinkId: string
+): QuestionnaireItem | null {
+  // Target linkId found in current item
+  if (qItem.linkId === targetLinkId) {
+    return qItem;
+  }
+
+  // Search through its child items recursively
+  const childQItems = qItem.item;
+  if (childQItems) {
+    for (const childQItem of childQItems) {
+      const foundQItem = getQuestionnaireItemRecursive(childQItem, targetLinkId);
+      if (foundQItem) {
+        return foundQItem;
+      }
+    }
+  }
+
+  // No matching item found in the current item or its child items, return null
+  return null;
+}
+
+///
+
+export function getParentItem(
+  questionnaire: Questionnaire,
+  targetLinkId: string
+): QuestionnaireItem | null {
+  // Search through the top level items recursively
+  const topLevelQItems = questionnaire.item;
+  if (topLevelQItems) {
+    for (const topLevelQItem of topLevelQItems) {
+      const foundParentQItem = getParentItemRecursive(topLevelQItem, targetLinkId);
+      if (foundParentQItem) {
+        return foundParentQItem;
+      }
+    }
+  }
+
+  // No matching parent item found in the questionnaire, return null
+  return null;
+}
+
+function getParentItemRecursive(
+  qItem: QuestionnaireItem,
+  targetLinkId: string,
+  parentQItem?: QuestionnaireItem
+): QuestionnaireItem | null {
+  // Current item has the target linkId, return the parent item if it exists
+  if (qItem.linkId === targetLinkId) {
+    return parentQItem ?? null;
+  }
+
+  // Search through its child items recursively
+  const childQItems = qItem.item;
+  if (childQItems) {
+    for (const childQItem of childQItems) {
+      const foundParentQItem = getParentItemRecursive(childQItem, targetLinkId, qItem);
+      if (foundParentQItem) {
+        return foundParentQItem;
+      }
+    }
+  }
+
+  // No matching parent item found in the current item or its child items, return null
+  return null;
+}
+
+export function getRepeatGroupParentItem(
+  questionnaire: Questionnaire,
+  targetLinkId: string
+): QuestionnaireItem | null {
+  // Search through the top level items recursively
+  const topLevelQItems = questionnaire.item;
+  if (topLevelQItems) {
+    for (const topLevelQItem of topLevelQItems) {
+      const foundParentQItem = getRepeatGroupParentItemRecursive(topLevelQItem, targetLinkId);
+      if (foundParentQItem) {
+        return foundParentQItem;
+      }
+    }
+  }
+
+  // No matching repeat group parent item found in the questionnaire, return null
+  return null;
+}
+
+function getRepeatGroupParentItemRecursive(
+  qItem: QuestionnaireItem,
+  targetLinkId: string,
+  repeatGroupParentQItem?: QuestionnaireItem
+): QuestionnaireItem | null {
+  // Current item has the target linkId, return the parent item if it exists
+  if (qItem.linkId === targetLinkId && repeatGroupParentQItem) {
+    return repeatGroupParentQItem ?? null;
+  }
+
+  // Check if the current item is a repeat group
+  const isRepeatGroup = qItem.repeats && qItem.type === 'group';
+
+  // Search through its child items recursively
+  const childQItems = qItem.item;
+  if (childQItems) {
+    for (const childQItem of childQItems) {
+      const foundParentQItem = getRepeatGroupParentItemRecursive(
+        childQItem,
+        targetLinkId,
+        isRepeatGroup ? qItem : repeatGroupParentQItem
+      );
+      if (foundParentQItem) {
+        return foundParentQItem;
+      }
+    }
+  }
+
+  // No matching repeat group parent item found in the current item or its child items, return null
+  return null;
+}

package/src/utils/qItem.ts

@@ -19,28 +19,51 @@ import type { Extension, Questionnaire, QuestionnaireItem } from 'fhir/r4';
 import { getChoiceControlType } from './choice';
 import { ChoiceItemControl, OpenChoiceItemControl } from '../interfaces/choice.enum';
 import { getOpenChoiceControlType } from './openChoice';
-import type { EnableWhenExpression, EnableWhenItems } from '../interfaces/enableWhen.interface';
+import type { EnableWhenExpression, EnableWhenItems } from '../interfaces';
 
 interface isHiddenByEnableWhensParams {
   linkId: string;
   enableWhenIsActivated: boolean;
   enableWhenItems: EnableWhenItems;
   enableWhenExpressions: Record<string, EnableWhenExpression>;
+  parentRepeatGroupIndex?: number;
 }
 
 export function isHiddenByEnableWhen(params: isHiddenByEnableWhensParams): boolean {
-  const { linkId, enableWhenIsActivated, enableWhenItems, enableWhenExpressions } = params;
+  const {
+    linkId,
+    enableWhenIsActivated,
+    enableWhenItems,
+    enableWhenExpressions,
+    parentRepeatGroupIndex
+  } = params;
+
+  const { singleItems, repeatItems } = enableWhenItems;
+
+  // If enableWhen is not activated, items are not hidden by enableWhen
+  if (!enableWhenIsActivated) {
+    return false;
+  }
 
-  if (enableWhenIsActivated) {
-    if (enableWhenItems[linkId]) {
-      return !enableWhenItems[linkId].isEnabled;
-    }
+  if (singleItems[linkId]) {
+    return !singleItems[linkId].isEnabled;
+  }
 
-    if (enableWhenExpressions[linkId]) {
-      return !enableWhenExpressions[linkId].isEnabled;
+  if (repeatItems[linkId] && parentRepeatGroupIndex !== undefined) {
+    return !repeatItems[linkId].enabledIndexes[parentRepeatGroupIndex];
+  }
+
+  if (enableWhenExpressions[linkId] && parentRepeatGroupIndex !== undefined) {
+    const isEnabledMultiple = enableWhenExpressions[linkId].isEnabledMultiple;
+    if (isEnabledMultiple) {
+      return !isEnabledMultiple[parentRepeatGroupIndex];
     }
   }
 
+  if (enableWhenExpressions[linkId]) {
+    return !enableWhenExpressions[linkId].isEnabledSingle;
+  }
+
   return false;
 }
 

package/src/utils/questionnaireStoreUtils/createQuestionaireModel.ts

@@ -100,7 +100,7 @@ function createEmptyModel(): QuestionnaireModel {
     calculatedExpressions: {},
     enableWhenExpressions: {},
     answerExpressions: {},
-    enableWhenItems: {},
+    enableWhenItems: { singleItems: {}, repeatItems: {} },
     processedValueSetCodings: {},
     processedValueSetUrls: {},
     fhirPathContext: {}