@aehrc/smart-forms-renderer 0.7.0 → 0.7.2

package/src/stores/useQuestionnaireStore.ts

@@ -42,6 +42,7 @@ import useTerminologyServerStore from './useTerminologyServerStore';
 
 export interface UseQuestionnaireStoreType {
   sourceQuestionnaire: Questionnaire;
+  itemTypes: Record<string, string>;
   tabs: Tabs;
   currentTabIndex: number;
   variables: Variables;
@@ -68,11 +69,15 @@ export interface UseQuestionnaireStoreType {
   toggleEnableWhenActivation: (isActivated: boolean) => void;
   updateExpressions: (updatedResponse: QuestionnaireResponse) => void;
   addCodingToCache: (valueSetUrl: string, codings: Coding[]) => void;
-  updatePopulatedProperties: (populatedResponse: QuestionnaireResponse) => QuestionnaireResponse;
+  updatePopulatedProperties: (
+    populatedResponse: QuestionnaireResponse,
+    persistTabIndex?: boolean
+  ) => QuestionnaireResponse;
 }
 
 const useQuestionnaireStore = create<UseQuestionnaireStoreType>()((set, get) => ({
   sourceQuestionnaire: cloneDeep(emptyQuestionnaire),
+  itemTypes: {},
   tabs: {},
   currentTabIndex: 0,
   variables: { fhirPathVariables: {}, xFhirQueryVariables: {} },
@@ -115,6 +120,7 @@ const useQuestionnaireStore = create<UseQuestionnaireStoreType>()((set, get) =>
 
     set({
       sourceQuestionnaire: questionnaire,
+      itemTypes: questionnaireModel.itemTypes,
       tabs: questionnaireModel.tabs,
       currentTabIndex: firstVisibleTab,
       variables: questionnaireModel.variables,
@@ -131,6 +137,7 @@ const useQuestionnaireStore = create<UseQuestionnaireStoreType>()((set, get) =>
   destroySourceQuestionnaire: () =>
     set({
       sourceQuestionnaire: cloneDeep(emptyQuestionnaire),
+      itemTypes: {},
       tabs: {},
       currentTabIndex: 0,
       variables: { fhirPathVariables: {}, xFhirQueryVariables: {} },
@@ -197,7 +204,7 @@ const useQuestionnaireStore = create<UseQuestionnaireStoreType>()((set, get) =>
         [valueSetUrl]: codings
       }
     })),
-  updatePopulatedProperties: (populatedResponse: QuestionnaireResponse) => {
+  updatePopulatedProperties: (populatedResponse: QuestionnaireResponse, persistTabIndex) => {
     const initialCalculatedExpressions = evaluateInitialCalculatedExpressions({
       initialResponse: populatedResponse,
       calculatedExpressions: get().calculatedExpressions,
@@ -229,7 +236,7 @@ const useQuestionnaireStore = create<UseQuestionnaireStoreType>()((set, get) =>
       enableWhenLinkedQuestions: initialEnableWhenLinkedQuestions,
       enableWhenExpressions: initialEnableWhenExpressions,
       calculatedExpressions: initialCalculatedExpressions,
-      currentTabIndex: firstVisibleTab
+      currentTabIndex: persistTabIndex ? get().currentTabIndex : firstVisibleTab
     }));
 
     return updatedResponse;

package/src/theme/overrides/Overrides.ts

@@ -20,7 +20,6 @@ import Paper from './Paper';
 import Input from './Input';
 import Table from './Table';
 import Button from './Button';
-import Backdrop from './Backdrop';
 import Autocomplete from './Autocomplete';
 import Accordion from './Accordion';
 import SpeedDial from './SpeedDial';
@@ -34,7 +33,6 @@ function ComponentsOverrides(theme: Theme) {
     Input(theme),
     Paper(),
     Button(theme),
-    Backdrop(theme),
     Autocomplete(theme),
     SpeedDial(theme)
   );

package/src/utils/calculatedExpression.ts

@@ -30,7 +30,7 @@ import _isEqual from 'lodash/isEqual';
 import { emptyResponse } from './emptyResource';
 import { createFhirPathContext } from './fhirpath';
 import { getQrItemsIndex, mapQItemsIndex } from './mapItem';
-import { updateQrGroup } from './qrItem';
+import { updateQrItemsInGroup } from './qrItem';
 import cloneDeep from 'lodash.clonedeep';
 
 interface EvaluateInitialCalculatedExpressionsParams {
@@ -213,7 +213,7 @@ function initialiseItemCalculatedExpressionValueRecursive(
       }
 
       if (newQrItem) {
-        updateQrGroup(
+        updateQrItemsInGroup(
           newQrItem,
           null,
           qrItem ?? { linkId: qItem.linkId, text: qItem.text, item: [] },

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

@@ -134,116 +134,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: {},