@aehrc/smart-forms-renderer 0.7.0 → 0.7.2

package/src/utils/repopulateIntoResponse.ts

@@ -0,0 +1,153 @@
+import {
+  Questionnaire,
+  QuestionnaireItem,
+  QuestionnaireResponse,
+  QuestionnaireResponseItem
+} from 'fhir/r4';
+import { 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
+  };
+}

package/src/utils/repopulateItems.ts

@@ -0,0 +1,207 @@
+/*
+ * 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 {
+  Questionnaire,
+  QuestionnaireItem,
+  QuestionnaireResponse,
+  QuestionnaireResponseItem
+} from 'fhir/r4';
+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';
+
+export interface ItemToRepopulate {
+  qItem: QuestionnaireItem | null;
+  heading: string | null;
+  newQRItem: QuestionnaireResponseItem;
+  oldQRItem?: QuestionnaireResponseItem;
+}
+
+export function getItemsToRepopulate(
+  sourceQuestionnaire: Questionnaire,
+  itemTypes: Record<string, string>,
+  tabs: Tabs,
+  populatedResponse: QuestionnaireResponse,
+  updatableResponse: QuestionnaireResponse
+): Record<string, ItemToRepopulate> {
+  if (
+    !sourceQuestionnaire.item ||
+    sourceQuestionnaire.item.length === 0 ||
+    !populatedResponse.item ||
+    populatedResponse.item.length === 0 ||
+    !updatableResponse.item ||
+    updatableResponse.item.length === 0
+  ) {
+    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
+      };
+
+      return mapping;
+    },
+    {}
+  );
+
+  // Get corresponding old items from updatableResponse if they are different
+  for (const topLevelItem of updatableResponse.item) {
+    checkCorrespondingOldItemsRecursive(topLevelItem, itemTypes, itemsToRepopulate);
+  }
+
+  // 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,
+      heading,
+      tabs,
+      hasTabs,
+      itemsToRepopulate
+    );
+  }
+
+  return itemsToRepopulate;
+}
+
+// 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 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) {
+    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
+    // so we need to fix this one first it seems like
+
+    /* 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;
+        }
+      }
+    }
+
+    // /* 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,
+        heading,
+        tabs,
+        hasTabs,
+        itemsToRepopulate
+      );
+    }
+
+    return;
+  }
+
+  if (!itemsToRepopulate[qItem.linkId]) {
+    return;
+  }
+
+  itemsToRepopulate[qItem.linkId].qItem = qItem;
+  itemsToRepopulate[qItem.linkId].heading = heading;
+}
+
+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));
+    }
+
+    return populatedChildItems;
+  }
+
+  // record item if it is not a group item
+  return [qrItem];
+}
+
+function checkCorrespondingOldItemsRecursive(
+  qrItem: QuestionnaireResponseItem,
+  itemTypes: Record<string, string>,
+  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);
+    }
+
+    return;
+  }
+
+  const oldItem = qrItem;
+  const newItem = itemsToRepopulate[qrItem.linkId]?.newQRItem;
+
+  if (!newItem) {
+    return;
+  }
+
+  if (_isEqual(oldItem, newItem)) {
+    delete itemsToRepopulate[qrItem.linkId];
+    return;
+  }
+
+  // const filteredNewItems = newItems.filter((newItem) => !_isEqual(oldItem, newItem));
+
+  itemsToRepopulate[qrItem.linkId].oldQRItem = oldItem;
+}

package/src/utils/repopulateRepeatGroup.ts

@@ -0,0 +1,68 @@
+/*
+ * 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 { QuestionnaireItem } from 'fhir/r4';
+import type { ItemToRepopulate } from './repopulateItems';
+
+export function checkIsRepeatGroupToRepopulate(
+  qItem: QuestionnaireItem,
+  itemsToRepopulate: Record<string, ItemToRepopulate>
+) {
+  if (!qItem.item) {
+    return false;
+  }
+
+  for (const childItem of qItem.item) {
+    if (itemsToRepopulate[childItem.linkId]) {
+      return true;
+    }
+  }
+}
+
+export function getRepeatGroupToRepopulate(
+  qItem: QuestionnaireItem,
+  itemsToRepopulate: Record<string, ItemToRepopulate>
+) {
+  if (!qItem.item) {
+    return null;
+  }
+
+  const childLinkIds = qItem.item
+    .filter((childItem) => !!itemsToRepopulate[childItem.linkId])
+    .map((childItem) => childItem.linkId);
+
+  const childQRItemsToRepopulate = childLinkIds
+    .reduce((result: ItemToRepopulate[], linkId) => {
+      if (itemsToRepopulate[linkId]) {
+        result.push(itemsToRepopulate[linkId]);
+      }
+      return result;
+    }, [])
+    .map((itemToRepopulate) => itemToRepopulate.newQRItem);
+
+  const repeatGroupToRepopulate: ItemToRepopulate = {
+    heading: qItem.text ?? null,
+    qItem: qItem,
+    newQRItem: {
+      linkId: qItem.linkId,
+      text: qItem.text,
+      item: childQRItemsToRepopulate
+    }
+  };
+
+  return repeatGroupToRepopulate;
+}

package/lib/theme/overrides/Typography.d.ts

@@ -1,13 +0,0 @@
-import type { Theme } from '@mui/material/styles';
-export default function Typography(theme: Theme): {
-    MuiTypography: {
-        styleOverrides: {
-            paragraph: {
-                marginBottom: string;
-            };
-            gutterBottom: {
-                marginBottom: string;
-            };
-        };
-    };
-};

package/lib/theme/overrides/Typography.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"Typography.js","sourceRoot":"","sources":["../../../src/theme/overrides/Typography.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAIH,MAAM,CAAC,OAAO,UAAU,UAAU,CAAC,KAAY;IAC7C,OAAO;QACL,aAAa,EAAE;YACb,cAAc,EAAE;gBACd,SAAS,EAAE;oBACT,YAAY,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC;iBAC/B;gBACD,YAAY,EAAE;oBACZ,YAAY,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC;iBAC/B;aACF;SACF;KACF,CAAC;AACJ,CAAC"}

package/lib/utils/isHidden.d.ts

@@ -1,3 +0,0 @@
-import { EnableWhenExpression, EnableWhenItems } from '../interfaces/enableWhen.interface';
-import { QuestionnaireItem } from 'fhir/r4';
-export declare function IsHidden(qItem: QuestionnaireItem, enableWhenIsActivated: boolean, enableWhenItems: EnableWhenItems, enableWhenExpressions: Record<string, EnableWhenExpression>): boolean;

package/lib/utils/isHidden.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"isHidden.js","sourceRoot":"","sources":["../../src/utils/isHidden.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAIhD,MAAM,UAAU,QAAQ,CACtB,KAAwB,EACxB,qBAA8B,EAC9B,eAAgC,EAChC,qBAA2D;IAE3D,IAAI,kBAAkB,CAAC,KAAK,CAAC,EAAE;QAC7B,OAAO,IAAI,CAAC;KACb;IAED,OAAO,qBAAqB,CAAC;QAC3B,MAAM,EAAE,KAAK,CAAC,MAAM;QACpB,qBAAqB;QACrB,eAAe;QACf,qBAAqB;KACtB,CAAC,CAAC;AACL,CAAC"}