@aehrc/smart-forms-renderer 0.7.1 → 0.8.0

package/src/utils/formChanges.ts

@@ -0,0 +1,141 @@
+/*
+ * 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 type { QuestionnaireResponseItemAnswer } from 'fhir/r4';
+
+type JsonDiffOperator = '+' | '-' | '~' | ' ';
+
+type QuestionnaireResponseItemDiffArray = [JsonDiffOperator, QuestionnaireResponseDiffItem];
+type QuestionnaireResponseItemAnswerDiffArray = [JsonDiffOperator, QuestionnaireResponseItemAnswer];
+
+interface QuestionnaireResponseDiffItem {
+  linkId: string;
+  item: QuestionnaireResponseItemDiffArray[] | undefined;
+  answer:
+    | QuestionnaireResponseItemAnswer[]
+    | QuestionnaireResponseItemAnswerDiffArray[]
+    | undefined;
+}
+
+interface ItemChange {
+  linkId: string;
+  itemType: string;
+  operation: 'add' | 'remove' | 'update';
+  value: QuestionnaireResponseItemAnswer;
+}
+
+export function readFormChanges(formChanges: object, itemTypes: Record<string, string>) {
+  if (!('item' in formChanges)) {
+    return {};
+  }
+
+  const changedItems: Record<string, ItemChange | null> = {};
+  const diffArrays = formChanges.item as QuestionnaireResponseItemDiffArray[];
+  for (const diffArray of diffArrays) {
+    readItemChangesRecursive(diffArray, itemTypes, changedItems);
+  }
+
+  return changedItems;
+}
+
+export function readItemChangesRecursive(
+  diffArray: QuestionnaireResponseItemDiffArray,
+  itemTypes: Record<string, string>,
+  changedItems: Record<string, ItemChange | null>
+) {
+  const operator = diffArray[0];
+  const diffItem = diffArray[1];
+
+  if (!operator || !diffItem) {
+    return changedItems;
+  }
+
+  changedItems[diffItem.linkId] = null;
+
+  const childDiffArrays = diffItem.item;
+  if (childDiffArrays && childDiffArrays.length > 0) {
+    for (const childDiffArray of childDiffArrays) {
+      readItemChangesRecursive(childDiffArray, itemTypes, changedItems);
+    }
+  }
+
+  // if (operator !== ' ') {
+  //   console.log(operator, diffItem);
+  // }
+
+  // explore answer diff arrays
+  // exmaple: [["+", {"valueString": "test"}], ["-", {"valueString": "test"}]]
+  // or it could be a regular answer array
+  // exmaple: [{"valueString": "test"}, {"valueString": "test"}]
+
+  const answerDiffArrays = diffItem.answer;
+  if (answerDiffArrays && isAnswerDiffArray(answerDiffArrays)) {
+    for (const answerDiffArray of answerDiffArrays) {
+      getItemChange(diffItem, answerDiffArray, itemTypes, changedItems);
+    }
+  }
+
+  return changedItems;
+}
+
+function getItemChange(
+  diffItem: QuestionnaireResponseDiffItem,
+  answerDiffArray: QuestionnaireResponseItemAnswerDiffArray,
+  itemTypes: Record<string, string>,
+  changedItems: Record<string, ItemChange | null>
+) {
+  const operator = answerDiffArray[0];
+  const answer = answerDiffArray[1];
+
+  if (operator === ' ') {
+    return;
+  }
+
+  const itemType = itemTypes[diffItem.linkId];
+  const operation = answerDiffOperationSwitcher(operator);
+  if (operation) {
+    changedItems[diffItem.linkId] = {
+      linkId: diffItem.linkId,
+      itemType: itemType,
+      operation: operation,
+      value: answer
+    };
+  }
+}
+
+function answerDiffOperationSwitcher(operator: JsonDiffOperator): ItemChange['operation'] | null {
+  switch (operator) {
+    case '+':
+      return 'add';
+    case '-':
+      return 'remove';
+    case '~':
+      return 'update';
+    default:
+      return null;
+  }
+}
+
+// type predicates
+function isAnswerDiffArray(answer: any[]): answer is QuestionnaireResponseItemAnswerDiffArray[] {
+  return answer.every(
+    (answerItem) =>
+      Array.isArray(answerItem) &&
+      typeof answerItem[0] === 'string' &&
+      typeof answerItem[1] === 'object'
+  );
+}

package/src/utils/index.ts

@@ -0,0 +1,18 @@
+/*
+ * 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.
+ */
+
+export { isSpecificItemControl } from './itemControl';

package/src/utils/mapItem.ts

@@ -15,7 +15,7 @@
  * limitations under the License.
  */
 
-import type { QuestionnaireItem, QuestionnaireResponseItem } from 'fhir/r4';
+import type { Questionnaire, QuestionnaireItem, QuestionnaireResponseItem } from 'fhir/r4';
 import { isRepeatItemAndNotCheckbox } from './qItem';
 
 /**
@@ -84,13 +84,15 @@ export function getQrItemsIndex(
  *
  * @author Sean Fong
  */
-export function mapQItemsIndex(qGroup: QuestionnaireItem): Record<string, number> {
-  if (!qGroup.item) {
+export function mapQItemsIndex(
+  questionnaireOrQItem: QuestionnaireItem | Questionnaire
+): Record<string, number> {
+  if (!questionnaireOrQItem.item) {
     return {};
   }
 
   // generate a <linkId, QItemIndex> dictionary
-  return qGroup.item.reduce((mapping: Record<string, number>, item, i) => {
+  return questionnaireOrQItem.item.reduce((mapping: Record<string, number>, item, i) => {
     mapping[item.linkId] = i;
     return mapping;
   }, {});

package/src/utils/qItem.ts

@@ -101,3 +101,32 @@ export function getXHtmlStringFromQuestionnaire(questionnaire: Questionnaire): s
   }
   return null;
 }
+
+export function getLinkIdTypeTuples(questionnaire: Questionnaire): [string, string][] {
+  if (!questionnaire.item || questionnaire.item.length === 0) {
+    return [];
+  }
+
+  const linkIds: [string, string][] = [];
+  for (const topLevelItem of questionnaire.item) {
+    linkIds.push(...getLinkIdTypeTuplesFromItemRecursive(topLevelItem));
+  }
+
+  return linkIds;
+}
+
+export function getLinkIdTypeTuplesFromItemRecursive(qItem: QuestionnaireItem): [string, string][] {
+  const linkIds: [string, string][] = [];
+
+  if (qItem.linkId) {
+    linkIds.push([qItem.linkId, qItem.type]);
+  }
+
+  if (qItem.item) {
+    for (const childItem of qItem.item) {
+      linkIds.push(...getLinkIdTypeTuplesFromItemRecursive(childItem));
+    }
+  }
+
+  return linkIds;
+}

package/src/utils/qrItem.ts

@@ -25,12 +25,13 @@ import type {
 import type { QrRepeatGroup } from '../interfaces/repeatGroup.interface';
 
 /**
- * Create a questionnaireResponse from a given questionnaire form item
- * A questionnaire form item is the first item of a questionnaire
+ * Create an empty questionnaireResponse from a given questionnaire
  *
  * @author Sean Fong
  */
-export function createQuestionnaireResponse(questionnaire: Questionnaire): QuestionnaireResponse {
+export function createEmptyQuestionnaireResponse(
+  questionnaire: Questionnaire
+): QuestionnaireResponse {
   const questionnaireResponse: QuestionnaireResponse = {
     resourceType: 'QuestionnaireResponse',
     status: 'in-progress'
@@ -134,116 +135,126 @@ export function createEmptyQrItemWithUnit(
  *
  * @author Sean Fong
  */
-export function updateQrGroup(
+export function updateQrItemsInGroup(
   newQrItem: QuestionnaireResponseItem | null,
   newQrRepeatGroup: QrRepeatGroup | null,
-  qrGroup: QuestionnaireResponseItem,
+  questionnaireResponseOrQrItem: QuestionnaireResponseItem | QuestionnaireResponse,
   qItemsIndexMap: Record<string, number>
 ): void {
-  if (qrGroup['item']) {
-    // Get actual sequence indexes of qrItems present within a qrGroup
-    // e.g. qrGroup has 4 fields but only the 2nd and 3rd field have values - resulting array is [1, 2]
-    const qrItemsRealIndexArr = qrGroup.item.map((qrItem) => qItemsIndexMap[qrItem.linkId]);
-
-    if (newQrItem && newQrItem.linkId in qItemsIndexMap) {
-      if (qrGroup.item.length === 0) {
-        qrGroup.item.push(newQrItem);
-      } else {
-        // Get actual sequence index of qrItem within qrGroup
-        const newQrItemIndex = qItemsIndexMap[newQrItem.linkId];
-
-        for (let i = 0; i < qrItemsRealIndexArr.length; i++) {
-          // Add qrItem at the end of qrGroup if it is larger than the other indexes
-          if (newQrItemIndex > qrItemsRealIndexArr[i]) {
-            if (i === qrItemsRealIndexArr.length - 1) {
-              qrGroup.item.push(newQrItem);
-            }
-            continue;
-          }
+  const qrItems = questionnaireResponseOrQrItem.item;
+  if (!qrItems) {
+    return;
+  }
 
-          // Replace or delete qrItem at its supposed position if its index is already present within qrGroup
-          if (newQrItemIndex === qrItemsRealIndexArr[i]) {
-            if (newQrItem.item?.length || newQrItem.answer?.length) {
-              // newQrItem has answer value
-              qrGroup.item[i] = newQrItem;
-            } else {
-              // newQrItem has no answer value
-              qrGroup.item.splice(i, 1);
-            }
-            break;
-          }
+  // Get actual sequence indexes of qrItems present within a qrGroup
+  // e.g. qrGroup has 4 fields but only the 2nd and 3rd field have values - resulting array is [1, 2]
+  const qrItemsRealIndexArr = qrItems.map((qrItem) => qItemsIndexMap[qrItem.linkId]);
 
-          // Add qrItem at its supposed position if its index is not present within qrGroup
-          if (newQrItemIndex < qrItemsRealIndexArr[i]) {
-            qrGroup.item.splice(i, 0, newQrItem);
-            break;
-          }
+  if (newQrItem && newQrItem.linkId in qItemsIndexMap) {
+    if (qrItems.length === 0) {
+      qrItems.push(newQrItem);
+      return;
+    }
+
+    // Get actual sequence index of qrItem within qrGroup
+    const newQrItemIndex = qItemsIndexMap[newQrItem.linkId];
+    for (let i = 0; i < qrItemsRealIndexArr.length; i++) {
+      // Add qrItem at the end of qrGroup if it is larger than the other indexes
+      if (newQrItemIndex > qrItemsRealIndexArr[i]) {
+        if (i === qrItemsRealIndexArr.length - 1) {
+          qrItems.push(newQrItem);
         }
+        continue;
       }
-    } else if (newQrRepeatGroup && newQrRepeatGroup.linkId in qItemsIndexMap) {
-      const newQrItems = newQrRepeatGroup.qrItems;
-      if (qrGroup.item.length === 0) {
-        qrGroup.item.push(...newQrItems);
-      } else {
-        // Get actual sequence index of qrItems within qrGroup
-        const newQrItemIndex = qItemsIndexMap[newQrRepeatGroup.linkId];
-
-        for (let i = 0; i < qrItemsRealIndexArr.length; i++) {
-          // Add qrItem at the end of qrGroup if it is larger than the other indexes
-          if (newQrItemIndex > qrItemsRealIndexArr[i]) {
-            if (i === qrItemsRealIndexArr.length - 1) {
-              qrGroup.item.push(...newQrItems);
-            }
-            continue;
-          }
 
-          // Replace or delete qrItem at its supposed position if its index is already present within qrGroup
-          if (newQrItemIndex === qrItemsRealIndexArr[i]) {
-            // Get number of repeatGroupItems that has the same linkId present in qrGroup
-            let repeatGroupItemCount = 0;
-            while (newQrItemIndex === qrItemsRealIndexArr[i + repeatGroupItemCount]) {
-              repeatGroupItemCount++;
-            }
+      // Replace or delete qrItem at its supposed position if its index is already present within qrGroup
+      if (newQrItemIndex === qrItemsRealIndexArr[i]) {
+        // newQrItem has answer value
+        if (newQrItem.item?.length || newQrItem.answer?.length) {
+          qrItems[i] = newQrItem;
+          break;
+        }
 
-            // Replace each repeat group qrItem with their new counterparts
-            if (newQrItems.length === repeatGroupItemCount) {
-              for (let j = 0; j < newQrItems.length; j++) {
-                qrGroup.item[i + j] = newQrItems[j];
-              }
-              break;
-            } else if (newQrItems.length > repeatGroupItemCount) {
-              // Replace each repeat group qrItem with their new counterparts,
-              // followed by adding an extra newQrItem behind the newly replaced qrItems
-              for (let j = 0, k = repeatGroupItemCount; j < newQrItems.length; j++, k--) {
-                if (k > 0) {
-                  qrGroup.item[i + j] = newQrItems[j];
-                } else {
-                  qrGroup.item.splice(i + j, 0, newQrItems[j]);
-                }
-              }
-              break;
-            } else if (newQrItems.length < repeatGroupItemCount) {
-              // Replace each repeat group qrItem with their new counterparts (except the last one),
-              // followed by deleting the last newQrItem which wasn't replaced
-              for (let j = 0; j < repeatGroupItemCount; j++) {
-                if (j <= newQrItems.length - 1) {
-                  qrGroup.item[i + j] = newQrItems[j];
-                } else {
-                  qrGroup.item.splice(i + j, 1);
-                }
-              }
-              break;
+        // newQrItem has no answer value
+        qrItems.splice(i, 1);
+        break;
+      }
+
+      // Add qrItem at its supposed position if its index is not present within qrGroup
+      if (newQrItemIndex < qrItemsRealIndexArr[i]) {
+        qrItems.splice(i, 0, newQrItem);
+        break;
+      }
+    }
+  }
+
+  if (newQrRepeatGroup && newQrRepeatGroup.linkId in qItemsIndexMap) {
+    const newQrItems = newQrRepeatGroup.qrItems;
+    if (qrItems.length === 0) {
+      qrItems.push(...newQrItems);
+      return;
+    }
+
+    // Get actual sequence index of qrItems within qrGroup
+    const newQrItemIndex = qItemsIndexMap[newQrRepeatGroup.linkId];
+    for (let i = 0; i < qrItemsRealIndexArr.length; i++) {
+      // Add qrItem at the end of qrGroup if it is larger than the other indexes
+      if (newQrItemIndex > qrItemsRealIndexArr[i]) {
+        if (i === qrItemsRealIndexArr.length - 1) {
+          qrItems.push(...newQrItems);
+        }
+        continue;
+      }
+
+      // Replace or delete qrItem at its supposed position if its index is already present within qrGroup
+      if (newQrItemIndex === qrItemsRealIndexArr[i]) {
+        // Get number of repeatGroupItems that has the same linkId present in qrGroup
+        let repeatGroupItemCount = 0;
+        while (newQrItemIndex === qrItemsRealIndexArr[i + repeatGroupItemCount]) {
+          repeatGroupItemCount++;
+        }
+
+        // Replace each repeat group qrItem with their new counterparts
+        if (newQrItems.length === repeatGroupItemCount) {
+          for (let j = 0; j < newQrItems.length; j++) {
+            qrItems[i + j] = newQrItems[j];
+          }
+          break;
+        }
+
+        if (newQrItems.length > repeatGroupItemCount) {
+          // Replace each repeat group qrItem with their new counterparts,
+          // followed by adding an extra newQrItem behind the newly replaced qrItems
+          for (let j = 0, k = repeatGroupItemCount; j < newQrItems.length; j++, k--) {
+            if (k > 0) {
+              qrItems[i + j] = newQrItems[j];
+            } else {
+              qrItems.splice(i + j, 0, newQrItems[j]);
             }
           }
+          break;
+        }
 
-          // Add qrItem at its supposed position if its index is not present within qrGroup
-          if (newQrItemIndex < qrItemsRealIndexArr[i]) {
-            for (let j = 0; j < newQrItems.length; j++) {
-              qrGroup.item.splice(i + j, 0, newQrItems[j]);
+        if (newQrItems.length < repeatGroupItemCount) {
+          // Replace each repeat group qrItem with their new counterparts (except the last one),
+          // followed by deleting the last newQrItem which wasn't replaced
+          for (let j = 0; j < repeatGroupItemCount; j++) {
+            if (j <= newQrItems.length - 1) {
+              qrItems[i + j] = newQrItems[j];
+            } else {
+              qrItems.splice(i + j, 1);
             }
-            break;
           }
+          break;
+        }
+      }
+
+      // Add qrItem at its supposed position if its index is not present within qrGroup
+      if (newQrItemIndex < qrItemsRealIndexArr[i]) {
+        for (let j = 0; j < newQrItems.length; j++) {
+          qrItems.splice(i + j, 0, newQrItems[j]);
         }
+        break;
       }
     }
   }

package/src/utils/questionnaireStoreUtils/createQuestionaireModel.ts

@@ -27,6 +27,7 @@ import { extractOtherExtensions } from './extractOtherExtensions';
 import type { Variables } from '../../interfaces/variables.interface';
 import { resolveValueSets } from './resolveValueSets';
 import { addAdditionalVariables } from './addAdditionalVariables';
+import { getLinkIdTypeTuples } from '../qItem';
 
 export async function createQuestionnaireModel(
   questionnaire: Questionnaire,
@@ -37,6 +38,7 @@ export async function createQuestionnaireModel(
     return createEmptyModel();
   }
 
+  const itemTypes: Record<string, string> = Object.fromEntries(getLinkIdTypeTuples(questionnaire));
   const tabs: Tabs = extractTabs(questionnaire);
 
   const launchContexts: Record<string, LaunchContext> = extractLaunchContexts(questionnaire);
@@ -75,6 +77,7 @@ export async function createQuestionnaireModel(
   processedValueSetCodings = resolveValueSetsResult.processedValueSetCodings;
 
   return {
+    itemTypes,
     tabs,
     variables,
     launchContexts,
@@ -89,6 +92,7 @@ export async function createQuestionnaireModel(
 
 function createEmptyModel(): QuestionnaireModel {
   return {
+    itemTypes: {},
     tabs: {},
     variables: { fhirPathVariables: {}, xFhirQueryVariables: {} },
     launchContexts: {},

package/src/utils/repopulateIntoResponse.ts

@@ -0,0 +1,153 @@
+import type {
+  Questionnaire,
+  QuestionnaireItem,
+  QuestionnaireResponse,
+  QuestionnaireResponseItem
+} from 'fhir/r4';
+import type { ItemToRepopulate } from './repopulateItems';
+import { getQrItemsIndex, mapQItemsIndex } from './mapItem';
+import { updateQrItemsInGroup } from './qrItem';
+
+export function repopulateItemsIntoResponse(
+  questionnaire: Questionnaire,
+  updatableResponse: QuestionnaireResponse,
+  checkedItemsToRepopulate: Record<string, ItemToRepopulate>
+): QuestionnaireResponse {
+  if (
+    !questionnaire.item ||
+    questionnaire.item.length === 0 ||
+    !updatableResponse.item ||
+    updatableResponse.item.length === 0
+  ) {
+    return updatableResponse;
+  }
+
+  const topLevelQrItems: QuestionnaireResponseItem[] = [];
+  for (const [index, topLevelQItem] of questionnaire.item.entries()) {
+    const repopulatedTopLevelQrItem = updatableResponse.item[index] ?? {
+      linkId: topLevelQItem.linkId,
+      text: topLevelQItem.text,
+      item: []
+    };
+
+    const updatedTopLevelQRItem = repopulateItemRecursive(
+      topLevelQItem,
+      repopulatedTopLevelQrItem,
+      checkedItemsToRepopulate
+    );
+
+    if (Array.isArray(updatedTopLevelQRItem)) {
+      if (updatedTopLevelQRItem.length > 0) {
+        topLevelQrItems.push(...updatedTopLevelQRItem);
+      }
+      continue;
+    }
+
+    if (updatedTopLevelQRItem) {
+      topLevelQrItems.push(updatedTopLevelQRItem);
+    }
+  }
+
+  return { ...updatableResponse, item: topLevelQrItems };
+}
+
+function repopulateItemRecursive(
+  qItem: QuestionnaireItem,
+  qrItem: QuestionnaireResponseItem | undefined,
+  checkedItemsToRepopulate: Record<string, ItemToRepopulate>
+): QuestionnaireResponseItem[] | QuestionnaireResponseItem | null {
+  const childQItems = qItem.item;
+  if (childQItems && childQItems.length > 0) {
+    // iterate through items of item recursively
+    const childQrItems = qrItem?.item ?? [];
+    // const updatedChildQrItems: QuestionnaireResponseItem[] = [];
+
+    // FIXME Not implemented for repeat groups
+    if (qItem.type === 'group' && qItem.repeats) {
+      return qrItem ?? null;
+    }
+
+    const indexMap = mapQItemsIndex(qItem);
+    const qrItemsByIndex = getQrItemsIndex(childQItems, childQrItems, indexMap);
+
+    // Otherwise loop through qItem as usual
+    for (const [index, childQItem] of childQItems.entries()) {
+      const childQrItem = qrItemsByIndex[index];
+
+      // FIXME Not implemented for repeat groups
+      if (Array.isArray(childQrItem)) {
+        continue;
+      }
+
+      const newQrItem = repopulateItemRecursive(childQItem, childQrItem, checkedItemsToRepopulate);
+
+      // FIXME Not implemented for repeat groups
+      if (Array.isArray(newQrItem)) {
+        continue;
+      }
+
+      if (newQrItem) {
+        updateQrItemsInGroup(
+          newQrItem,
+          null,
+          qrItem ?? { linkId: qItem.linkId, text: qItem.text, item: [] },
+          indexMap
+        );
+      }
+    }
+
+    return constructGroupItem(qItem, qrItem, checkedItemsToRepopulate);
+  }
+
+  return constructSingleItem(qItem, qrItem, checkedItemsToRepopulate);
+}
+
+function constructGroupItem(
+  qItem: QuestionnaireItem,
+  qrItem: QuestionnaireResponseItem | undefined,
+  checkedItemsToRepopulate: Record<string, ItemToRepopulate>
+): QuestionnaireResponseItem | null {
+  const itemToRepopulate = checkedItemsToRepopulate[qItem.linkId];
+
+  if (!itemToRepopulate) {
+    return qrItem ?? null;
+  }
+
+  if (qrItem) {
+    return {
+      ...qrItem,
+      answer: itemToRepopulate.newQRItem.answer
+    };
+  }
+
+  return {
+    linkId: qItem.linkId,
+    text: qItem.text,
+    answer: itemToRepopulate.newQRItem.answer
+  };
+}
+
+function constructSingleItem(
+  qItem: QuestionnaireItem,
+  qrItem: QuestionnaireResponseItem | undefined,
+  checkedItemsToRepopulate: Record<string, ItemToRepopulate>
+): QuestionnaireResponseItem | null {
+  const itemToRepopulate = checkedItemsToRepopulate[qItem.linkId];
+
+  if (!itemToRepopulate) {
+    return qrItem ?? null;
+  }
+
+  if (qrItem) {
+    return {
+      ...qrItem,
+      answer: itemToRepopulate.newQRItem.answer
+    };
+  }
+
+  return {
+    linkId: qItem.linkId,
+    text: qItem.text,
+    answer: itemToRepopulate.newQRItem.answer
+  };
+}