@aehrc/smart-forms-renderer 0.8.0 → 0.9.0

package/src/utils/repopulateItems.ts

@@ -24,26 +24,47 @@ import type {
 import type { Tabs } from '../interfaces/tab.interface';
 import _isEqual from 'lodash/isEqual';
 import { containsTabs, isTabContainer } from './tabs';
-import { getShortText } from './itemControl';
-import {
-  checkIsRepeatGroupToRepopulate,
-  getRepeatGroupToRepopulate
-} from './repopulateRepeatGroup';
+import { getShortText, isSpecificItemControl } from './itemControl';
+import { getQrItemsIndex, mapQItemsIndex } from './mapItem';
+import type { EnableWhenExpression, EnableWhenItems } from '../interfaces/enableWhen.interface';
+import { isHidden } from './qItem';
 
 export interface ItemToRepopulate {
   qItem: QuestionnaireItem | null;
   heading: string | null;
+
+  // for non-repeat groups
   newQRItem: QuestionnaireResponseItem;
   oldQRItem?: QuestionnaireResponseItem;
+
+  // for repeat groups
+  newQRItems: QuestionnaireResponseItem[];
+  oldQRItems?: QuestionnaireResponseItem[];
+}
+
+interface getItemsToRepopulateParams {
+  sourceQuestionnaire: Questionnaire;
+  tabs: Tabs;
+  populatedResponse: QuestionnaireResponse;
+  updatableResponse: QuestionnaireResponse;
+  enableWhenIsActivated: boolean;
+  enableWhenItems: EnableWhenItems;
+  enableWhenExpressions: Record<string, EnableWhenExpression>;
 }
 
 export function getItemsToRepopulate(
-  sourceQuestionnaire: Questionnaire,
-  itemTypes: Record<string, string>,
-  tabs: Tabs,
-  populatedResponse: QuestionnaireResponse,
-  updatableResponse: QuestionnaireResponse
+  params: getItemsToRepopulateParams
 ): Record<string, ItemToRepopulate> {
+  const {
+    sourceQuestionnaire,
+    tabs,
+    populatedResponse,
+    updatableResponse,
+    enableWhenIsActivated,
+    enableWhenItems,
+    enableWhenExpressions
+  } = params;
+
   if (
     !sourceQuestionnaire.item ||
     sourceQuestionnaire.item.length === 0 ||
@@ -55,152 +76,409 @@ export function getItemsToRepopulate(
     return {};
   }
 
-  const populatedItems: QuestionnaireResponseItem[] = [];
-  for (const topLevelItem of populatedResponse.item) {
-    populatedItems.push(...getPopulatedItemsRecursive(topLevelItem, itemTypes));
-  }
-
-  const itemsToRepopulate = populatedItems.reduce(
-    (mapping: Record<string, ItemToRepopulate>, item) => {
-      mapping[item.linkId] = {
-        qItem: null,
-        heading: null,
-        newQRItem: item
-      };
+  const topLevelQItems = sourceQuestionnaire.item;
+  const populatedTopLevelQRItems = populatedResponse.item;
 
-      return mapping;
-    },
-    {}
+  const qItemsIndexMap = mapQItemsIndex(sourceQuestionnaire);
+  const populatedTopLevelQRItemsByIndex = getQrItemsIndex(
+    topLevelQItems,
+    populatedTopLevelQRItems,
+    qItemsIndexMap
   );
 
-  // Get corresponding old items from updatableResponse if they are different
-  for (const topLevelItem of updatableResponse.item) {
-    checkCorrespondingOldItemsRecursive(topLevelItem, itemTypes, itemsToRepopulate);
-  }
+  const itemsToRepopulate: Record<string, ItemToRepopulate> = {};
+  for (const [index, topLevelQItem] of topLevelQItems.entries()) {
+    const populatedQrItemOrItems = populatedTopLevelQRItemsByIndex[index];
+    if (!populatedQrItemOrItems) {
+      continue;
+    }
 
-  // Get corresponding old items from updatableResponse if they are different
-  for (const topLevelItem of sourceQuestionnaire.item) {
-    const heading = topLevelItem.text ?? null;
-    const hasTabs = isTabContainer(topLevelItem) || containsTabs(topLevelItem);
-    getCorrespondingQuestionnaireItemsRecursive(
-      topLevelItem,
+    const heading = topLevelQItem.text ?? null;
+    const hasTabs = isTabContainer(topLevelQItem) || containsTabs(topLevelQItem);
+
+    getItemsToRepopulateRecursive({
+      qItem: topLevelQItem,
+      qrItemOrItems: populatedQrItemOrItems,
       heading,
       tabs,
       hasTabs,
-      itemsToRepopulate
-    );
+      itemsToRepopulate,
+      enableWhenIsActivated,
+      enableWhenItems,
+      enableWhenExpressions
+    });
+  }
+
+  const oldTopLevelQRItemsByIndex = getQrItemsIndex(
+    topLevelQItems,
+    updatableResponse.item,
+    qItemsIndexMap
+  );
+  for (const [index, topLevelQItem] of topLevelQItems.entries()) {
+    const oldQrItemOrItems = oldTopLevelQRItemsByIndex[index];
+    if (!oldQrItemOrItems) {
+      continue;
+    }
+
+    checkCorrespondingOldItemsRecursive(topLevelQItem, oldQrItemOrItems, itemsToRepopulate);
   }
 
   return itemsToRepopulate;
 }
 
+interface getItemsToRepopulateRecursiveParams {
+  qItem: QuestionnaireItem;
+  qrItemOrItems: QuestionnaireResponseItem | QuestionnaireResponseItem[];
+  heading: string | null;
+  tabs: Tabs;
+  hasTabs: boolean;
+  itemsToRepopulate: Record<string, ItemToRepopulate>;
+  enableWhenIsActivated: boolean;
+  enableWhenItems: EnableWhenItems;
+  enableWhenExpressions: Record<string, EnableWhenExpression>;
+}
+
 // 1. Get items to repopulate (only new items)
 // 2. Get corresponding old items from updatableResponse (if they are different)
 // 3. Compare old and new items in dialog - if there are none, show a dialog saying there is no new data
 // 4. Have checkboxes in dialog to update response
 // 5. Replace old answers with new answers
+function getItemsToRepopulateRecursive(params: getItemsToRepopulateRecursiveParams) {
+  const {
+    qItem,
+    qrItemOrItems,
+    tabs,
+    hasTabs,
+    itemsToRepopulate,
+    enableWhenIsActivated,
+    enableWhenItems,
+    enableWhenExpressions
+  } = params;
+  let { heading } = params;
 
-function getCorrespondingQuestionnaireItemsRecursive(
-  qItem: QuestionnaireItem,
-  heading: string | null,
-  tabs: Tabs,
-  hasTabs: boolean,
-  itemsToRepopulate: Record<string, ItemToRepopulate>
-): void {
-  if (qItem.type === 'group' && qItem.item && qItem.item.length > 0) {
+  if (!qrItemOrItems) {
+    return;
+  }
+
+  // Return nothing if corresponding qItem is hidden
+  if (
+    isHidden({
+      questionnaireItem: qItem,
+      enableWhenIsActivated,
+      enableWhenItems,
+      enableWhenExpressions
+    })
+  ) {
+    return null;
+  }
+
+  // For repeat groups
+  const hasMultipleAnswers = Array.isArray(qrItemOrItems);
+  if (hasMultipleAnswers) {
+    if (qrItemOrItems.length > 0) {
+      getRepeatGroupToRepopulate(qItem, qrItemOrItems, heading, itemsToRepopulate);
+    }
+    return;
+  }
+
+  const childQItems = qItem.item;
+  const childQRItems = qrItemOrItems.item;
+
+  if (childQItems && childQItems.length > 0 && childQRItems) {
     const isTab = !!tabs[qItem.linkId];
     if (isTab) {
       heading = getShortText(qItem) ?? qItem.text ?? null;
     }
 
-    // TODO it seems like there can only be one answer per linkId, we might need to do repeat groups differently
-
-    /* Repeat group implementation */
-    if (qItem.type === 'group' && qItem.repeats) {
-      const isRepeatGroupToRepopulate = checkIsRepeatGroupToRepopulate(qItem, itemsToRepopulate);
-      if (isRepeatGroupToRepopulate) {
-        const repeatGroupToRepopulate = getRepeatGroupToRepopulate(qItem, itemsToRepopulate);
-        if (repeatGroupToRepopulate) {
-          itemsToRepopulate[qItem.linkId] = repeatGroupToRepopulate;
-          return;
-        }
-      }
+    const qItemsIndexMap = mapQItemsIndex(qItem);
+    const populatedQRItemsByIndex = getQrItemsIndex(childQItems, childQRItems, qItemsIndexMap);
+
+    // For grid groups
+    const itemIsGrid = isSpecificItemControl(qItem, 'grid');
+    if (itemIsGrid) {
+      getGridTableToRepopulate({
+        qItem,
+        gridChildQItems: childQItems,
+        gridChildQRItemsByIndex: populatedQRItemsByIndex,
+        heading,
+        itemsToRepopulate,
+        enableWhenIsActivated,
+        enableWhenItems,
+        enableWhenExpressions
+      });
+      return;
     }
 
-    // /* Grid implementation */
-    // if (qItem.type === 'group' && isSpecificItemControl(qItem, 'grid')) {
-    //   const isRepeatGroupToRepopulate = checkIsRepeatGroupToRepopulate(qItem, itemsToRepopulate);
-    //   if (isRepeatGroupToRepopulate) {
-    //     getRepeatGroupToRepopulate(qItem, itemsToRepopulate);
-    //   }
-    // }
-
-    for (const childItem of qItem.item) {
-      getCorrespondingQuestionnaireItemsRecursive(
-        childItem,
+    // For normal groups with children
+    for (const [index, childQItem] of childQItems.entries()) {
+      const childQrItemOrItems = populatedQRItemsByIndex[index];
+      if (!childQrItemOrItems) {
+        continue;
+      }
+
+      getItemsToRepopulateRecursive({
+        qItem: childQItem,
+        qrItemOrItems: childQrItemOrItems,
         heading,
         tabs,
         hasTabs,
-        itemsToRepopulate
-      );
+        itemsToRepopulate,
+        enableWhenIsActivated,
+        enableWhenItems,
+        enableWhenExpressions
+      });
     }
 
+    const hasSingleAnswer = !Array.isArray(qrItemOrItems);
+    if (hasSingleAnswer && qrItemOrItems.answer) {
+      getSingleItemToRepopulate(qItem, qrItemOrItems, heading, itemsToRepopulate);
+    }
     return;
   }
 
-  if (!itemsToRepopulate[qItem.linkId]) {
+  // For single items without children
+  getSingleItemToRepopulate(qItem, qrItemOrItems, heading, itemsToRepopulate);
+}
+
+function getSingleItemToRepopulate(
+  qItem: QuestionnaireItem,
+  qrItem: QuestionnaireResponseItem,
+  heading: string | null,
+  itemsToRepopulate: Record<string, ItemToRepopulate>
+) {
+  itemsToRepopulate[qItem.linkId] = {
+    qItem: qItem,
+    heading: heading,
+    newQRItem: qrItem,
+    newQRItems: []
+  };
+}
+
+function getRepeatGroupToRepopulate(
+  qItem: QuestionnaireItem,
+  qrItems: QuestionnaireResponseItem[],
+  heading: string | null,
+  itemsToRepopulate: Record<string, ItemToRepopulate>
+) {
+  itemsToRepopulate[qItem.linkId] = {
+    qItem: qItem,
+    heading: heading,
+    newQRItem: {
+      linkId: qItem.linkId
+    },
+    newQRItems: qrItems
+  };
+}
+
+interface getGridTableToRepopulateParams {
+  qItem: QuestionnaireItem;
+  gridChildQItems: QuestionnaireItem[];
+  gridChildQRItemsByIndex: (QuestionnaireResponseItem | QuestionnaireResponseItem[] | undefined)[];
+  heading: string | null;
+  itemsToRepopulate: Record<string, ItemToRepopulate>;
+  enableWhenIsActivated: boolean;
+  enableWhenItems: EnableWhenItems;
+  enableWhenExpressions: Record<string, EnableWhenExpression>;
+}
+
+function getGridTableToRepopulate(params: getGridTableToRepopulateParams) {
+  const {
+    qItem,
+    gridChildQItems,
+    gridChildQRItemsByIndex,
+    heading,
+    itemsToRepopulate,
+    enableWhenIsActivated,
+    enableWhenItems,
+    enableWhenExpressions
+  } = params;
+
+  if (gridChildQItems.length === 0) {
     return;
   }
 
-  itemsToRepopulate[qItem.linkId].qItem = qItem;
-  itemsToRepopulate[qItem.linkId].heading = heading;
+  const gridChildQRItemsToRepopulate = gridChildQItems
+    .map((qItem, index) => {
+      if (
+        isHidden({
+          questionnaireItem: qItem,
+          enableWhenIsActivated,
+          enableWhenItems,
+          enableWhenExpressions
+        })
+      ) {
+        return null;
+      }
+
+      const gridChildQrItemOrItems = gridChildQRItemsByIndex?.[index];
+      if (gridChildQrItemOrItems && !Array.isArray(gridChildQrItemOrItems)) {
+        return gridChildQrItemOrItems;
+      }
+
+      return null;
+    })
+    .filter((item) => item !== null) as QuestionnaireResponseItem[];
+
+  itemsToRepopulate[qItem.linkId] = {
+    qItem: qItem,
+    heading: heading,
+    newQRItem: {
+      linkId: qItem.linkId,
+      text: qItem.text,
+      item: gridChildQRItemsToRepopulate
+    },
+    newQRItems: []
+  };
 }
 
-function getPopulatedItemsRecursive(
-  qrItem: QuestionnaireResponseItem,
-  itemTypes: Record<string, string>
-): QuestionnaireResponseItem[] {
-  const itemType = itemTypes[qrItem.linkId];
-  if (itemType === 'group' && qrItem.item && qrItem.item.length > 0) {
-    const populatedChildItems: QuestionnaireResponseItem[] = [];
-    for (const childItem of qrItem.item) {
-      populatedChildItems.push(...getPopulatedItemsRecursive(childItem, itemTypes));
+function checkCorrespondingOldItemsRecursive(
+  qItem: QuestionnaireItem,
+  oldQrItemOrItems: QuestionnaireResponseItem | QuestionnaireResponseItem[],
+  itemsToRepopulate: Record<string, ItemToRepopulate>
+) {
+  // For repeat groups
+  const hasMultipleAnswers = Array.isArray(oldQrItemOrItems);
+  if (hasMultipleAnswers) {
+    retrieveRepeatGroupOldQRItems(qItem, oldQrItemOrItems, itemsToRepopulate);
+    return;
+  }
+
+  const childQItems = qItem.item;
+  const oldChildQRItems = oldQrItemOrItems.item;
+
+  if (childQItems && childQItems.length > 0 && oldChildQRItems) {
+    const qItemsIndexMap = mapQItemsIndex(qItem);
+    const oldQRItemsByIndex = getQrItemsIndex(childQItems, oldChildQRItems, qItemsIndexMap);
+
+    // For grid groups
+    const itemIsGrid = isSpecificItemControl(qItem, 'grid');
+    if (itemIsGrid) {
+      retrieveGridGroupOldQRItems(qItem, childQItems, oldQRItemsByIndex, itemsToRepopulate);
+      return;
     }
 
-    return populatedChildItems;
+    // For normal groups with children
+    for (const [index, childQItem] of childQItems.entries()) {
+      const oldChildQrItemOrItems = oldQRItemsByIndex[index];
+      if (!oldChildQrItemOrItems) {
+        continue;
+      }
+
+      checkCorrespondingOldItemsRecursive(childQItem, oldChildQrItemOrItems, itemsToRepopulate);
+    }
+
+    const hasSingleAnswer = !Array.isArray(oldQrItemOrItems);
+    if (hasSingleAnswer && oldQrItemOrItems.answer) {
+      retrieveSingleOldQRItem(qItem, oldQrItemOrItems, itemsToRepopulate);
+    }
+    return;
   }
 
-  // record item if it is not a group item
-  return [qrItem];
+  // For single items without children
+  retrieveSingleOldQRItem(qItem, oldQrItemOrItems, itemsToRepopulate);
 }
 
-function checkCorrespondingOldItemsRecursive(
-  qrItem: QuestionnaireResponseItem,
-  itemTypes: Record<string, string>,
+function retrieveSingleOldQRItem(
+  qItem: QuestionnaireItem,
+  oldQRItem: QuestionnaireResponseItem,
   itemsToRepopulate: Record<string, ItemToRepopulate>
-): void {
-  const itemType = itemTypes[qrItem.linkId];
-  if (itemType === 'group' && qrItem.item && qrItem.item.length > 0) {
-    for (const childItem of qrItem.item) {
-      checkCorrespondingOldItemsRecursive(childItem, itemTypes, itemsToRepopulate);
-    }
+) {
+  const newQRItem = itemsToRepopulate[qItem.linkId]?.newQRItem;
 
+  if (!newQRItem) {
     return;
   }
 
-  const oldItem = qrItem;
-  const newItem = itemsToRepopulate[qrItem.linkId]?.newQRItem;
+  if (_isEqual(oldQRItem, newQRItem)) {
+    delete itemsToRepopulate[qItem.linkId];
+    return;
+  }
+
+  itemsToRepopulate[qItem.linkId].oldQRItem = oldQRItem;
+}
 
-  if (!newItem) {
+function retrieveRepeatGroupOldQRItems(
+  qItem: QuestionnaireItem,
+  oldQRItems: QuestionnaireResponseItem[],
+  itemsToRepopulate: Record<string, ItemToRepopulate>
+) {
+  if (!(qItem && oldQRItems && oldQRItems.length > 0)) {
+    return;
+  }
+
+  const newQRItems = itemsToRepopulate[qItem.linkId]?.newQRItems;
+  if (!newQRItems) {
+    return;
+  }
+
+  if (_isEqual(oldQRItems, newQRItems)) {
+    delete itemsToRepopulate[qItem.linkId];
+    return;
+  }
+
+  itemsToRepopulate[qItem.linkId].oldQRItems = oldQRItems;
+}
+
+function retrieveGridGroupOldQRItems(
+  qItem: QuestionnaireItem,
+  gridChildQItems: QuestionnaireItem[],
+  oldGridQRItemsByIndex: (QuestionnaireResponseItem | QuestionnaireResponseItem[] | undefined)[],
+  itemsToRepopulate: Record<string, ItemToRepopulate>
+) {
+  if (gridChildQItems.length === 0) {
     return;
   }
 
-  if (_isEqual(oldItem, newItem)) {
-    delete itemsToRepopulate[qrItem.linkId];
+  const newGridQRItem = itemsToRepopulate[qItem.linkId]?.newQRItem;
+  if (!newGridQRItem || !newGridQRItem.item) {
     return;
   }
 
-  // const filteredNewItems = newItems.filter((newItem) => !_isEqual(oldItem, newItem));
+  const newGridChildQRItemMap = new Map<string, QuestionnaireResponseItem>();
+
+  for (const newGridChildQRItem of newGridQRItem.item) {
+    newGridChildQRItemMap.set(newGridChildQRItem.linkId, newGridChildQRItem);
+  }
+
+  // Get old qr items that are different from the new qr items
+  const oldGridChildQRItems: QuestionnaireResponseItem[] = [];
+  for (const [index, gridChildQItem] of gridChildQItems.entries()) {
+    const oldGridChildQrItemOrItems = oldGridQRItemsByIndex[index];
+    if (!oldGridChildQrItemOrItems || Array.isArray(oldGridChildQrItemOrItems)) {
+      continue;
+    }
+
+    // At this point we have a single qrItem
+    const oldGridChildQrItem = oldGridChildQrItemOrItems;
+    const newGridChildQRItem = newGridChildQRItemMap.get(gridChildQItem.linkId);
+
+    if (!newGridChildQRItem) {
+      continue;
+    }
+
+    if (_isEqual(oldGridChildQrItem, newGridChildQRItem)) {
+      newGridChildQRItemMap.delete(gridChildQItem.linkId);
+    } else {
+      oldGridChildQRItems.push(oldGridChildQrItem);
+    }
+  }
+
+  const newGridChildQRItemsToRepopulate = [...newGridChildQRItemMap.values()];
+  // Nothing to repopulate, delete whole item
+  if (newGridChildQRItemsToRepopulate.length === 0) {
+    delete itemsToRepopulate[qItem.linkId];
+    return;
+  }
 
-  itemsToRepopulate[qrItem.linkId].oldQRItem = oldItem;
+  // Otherwise create both old and new grid qr item
+  itemsToRepopulate[qItem.linkId].newQRItem = {
+    linkId: qItem.linkId,
+    text: qItem.text,
+    item: newGridChildQRItemsToRepopulate
+  };
+  itemsToRepopulate[qItem.linkId].oldQRItem = {
+    linkId: qItem.linkId,
+    text: qItem.text,
+    item: oldGridChildQRItems
+  };
 }

package/src/utils/slider.ts

@@ -0,0 +1,112 @@
+/*
+ * 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 { Extension, QuestionnaireItem } from 'fhir/r4';
+
+/**
+ * Get Questionnaire slider step value if its extension is present (http://hl7.org/fhir/StructureDefinition/questionnaire-sliderStepValue)
+ *
+ * @author Sean Fong
+ */
+export function getSliderStepValue(qItem: QuestionnaireItem): number | null {
+  const itemControl = qItem.extension?.find(
+    (extension: Extension) =>
+      extension.url === 'http://hl7.org/fhir/StructureDefinition/questionnaire-sliderStepValue'
+  );
+
+  if (itemControl) {
+    if (itemControl.valueInteger) {
+      return itemControl.valueInteger;
+    }
+  }
+  return null;
+}
+
+/**
+ * Get minimum value if its extension is present (http://hl7.org/fhir/StructureDefinition/minValue)
+ * Only supports valueInteger and valueDecimal for now
+ *
+ * @author Sean Fong
+ */
+export function getMinValue(qItem: QuestionnaireItem): number | null {
+  const itemControl = qItem.extension?.find(
+    (extension: Extension) => extension.url === 'http://hl7.org/fhir/StructureDefinition/minValue'
+  );
+
+  if (itemControl) {
+    if (itemControl.valueInteger) {
+      return itemControl.valueInteger;
+    }
+
+    if (itemControl.valueDecimal) {
+      return itemControl.valueDecimal;
+    }
+  }
+  return null;
+}
+
+/**
+ * Get maximum value if its extension is present (http://hl7.org/fhir/StructureDefinition/maxValue)
+ * Only supports valueInteger and valueDecimal for now
+ *
+ * @author Sean Fong
+ */
+export function getMaxValue(qItem: QuestionnaireItem): number | null {
+  const itemControl = qItem.extension?.find(
+    (extension: Extension) => extension.url === 'http://hl7.org/fhir/StructureDefinition/maxValue'
+  );
+
+  if (itemControl) {
+    if (itemControl.valueInteger) {
+      return itemControl.valueInteger;
+    }
+
+    if (itemControl.valueDecimal) {
+      return itemControl.valueDecimal;
+    }
+  }
+  return null;
+}
+
+export function getSliderMarks(
+  minValue: number,
+  maxValue: number,
+  minLabel: string,
+  maxLabel: string,
+  stepValue: number
+) {
+  const numOfSteps = Math.ceil((maxValue - minValue) / stepValue);
+  if (numOfSteps > 20) {
+    return [
+      {
+        value: minValue,
+        label: minLabel !== '' ? minLabel : minValue.toString()
+      },
+      {
+        value: maxValue,
+        label: maxLabel !== '' ? maxLabel : maxValue.toString()
+      }
+    ];
+  }
+
+  return Array.from({ length: numOfSteps + 1 }, (_, i) => minValue + i * stepValue).map(
+    (value) => ({
+      value: value,
+      label: value
+    })
+  );
+}